Changeset dcbb03b for src/prelude

Timestamp:

Mar 1, 2018, 9:29:03 AM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

1f37ed02

Parents:

b002261 (diff), 446ffa3 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/prelude/builtins.c (modified) (1 diff)

src/prelude/builtins.c

@@ -58 +58 @@
 static inline long int ?\?( long int ep, unsigned long int y ) { // disallow negative exponent
         if ( y == 0 ) return 1;                                                         // base case
-    if ( ep == 2 ) return ep << (y - 1);                                // special case, positive shifting only
-    typeof( ep ) op = 1;                                                                // accumulate odd product
-    for ( ; y > 1; y >>= 1 ) {                                                  // squaring exponentiation, O(log2 y)
+        if ( ep == 2 ) return ep << (y - 1);                            // special case, positive shifting only
+        typeof( ep ) op = 1;                                                            // accumulate odd product
+        for ( ; y > 1; y >>= 1 ) {                                                      // squaring exponentiation, O(log2 y)
                 if ( (y & 1) == 1 ) op *= ep;                                   // odd ?
                 ep *= ep;
         } // for
-    return ep * op;
+        return ep * op;
 } // ?\?
 
-// FIX ME, cannot resolve the "T op = 1".
-
-// static inline forall( otype T | { void ?{}( T * this, one_t ); T ?*?( T, T ); } )
-// T ?\?( T ep, unsigned long int y ) {
-//     if ( y == 0 ) return 1;
-//     T op = 1;
-//     for ( ; y > 1; y >>= 1 ) {                                                       // squaring exponentiation, O(log2 y)
-//              if ( (y & 1) == 1 ) op = op * ep;                               // odd ?
-//              ep = ep * ep;
-//     } // for
-//     return ep * op;
-// } // ?\?
+static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
+T ?\?( T ep, unsigned long int y ) {
+        if ( y == 0 ) return 1;
+        T op = 1;
+        for ( ; y > 1; y >>= 1 ) {                                                      // squaring exponentiation, O(log2 y)
+                if ( (y & 1) == 1 ) op = op * ep;                               // odd ?
+                ep = ep * ep;
+        } // for
+        return ep * op;
+} // ?\?
 
 // unsigned computation may be faster and larger
 static inline unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { // disallow negative exponent
         if ( y == 0 ) return 1;                                                         // base case
-    if ( ep == 2 ) return ep << (y - 1);                                // special case, positive shifting only
-    typeof( ep ) op = 1;                                                                // accumulate odd product
-    for ( ; y > 1; y >>= 1 ) {                                                  // squaring exponentiation, O(log2 y)
+        if ( ep == 2 ) return ep << (y - 1);                            // special case, positive shifting only
+        typeof( ep ) op = 1;                                                            // accumulate odd product
+        for ( ; y > 1; y >>= 1 ) {                                                      // squaring exponentiation, O(log2 y)
                 if ( (y & 1) == 1 ) op *= ep;                                   // odd ?
                 ep *= ep;
         } // for
-    return ep * op;
+        return ep * op;
 } // ?\?
 
 static inline double ?\?( long int x, signed long int y ) {     // allow negative exponent
-    if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
-    else return 1.0 / x \ (unsigned int)(-y);
+        if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
+        else return 1.0 / x \ (unsigned int)(-y);
 } // ?\?