Changeset b46e3bd

Timestamp:

Jul 17, 2017, 1:59:53 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

89be1c68

Parents:

a493682

Message:

Update Cost structure to include static unsafe, poly, safe members

Location:

src/ResolvExpr

Files:

• ConversionCost.cc (modified) (1 diff)
• Cost.h (modified) (4 diffs)

src/ResolvExpr/ConversionCost.cc

@@ -23 +23 @@
         const Cost Cost::zero = Cost( 0, 0, 0 );
         const Cost Cost::infinity = Cost( -1, -1, -1 );
+        const Cost Cost::unsafe = Cost( 1, 0, 0 );
+        const Cost Cost::poly = Cost( 0, 1, 0 );
+        const Cost Cost::safe = Cost( 0, 0, 1 );
+
 
         Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {

src/ResolvExpr/Cost.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Cost.h -- 
+// Cost.h --
 //
 // Author           : Richard C. Bilson
@@ -23 +23 @@
           public:
                 Cost();
-                Cost( int unsafe, int poly, int safe );
-  
+                Cost( int unsafeCost, int polyCost, int safeCost );
+
                 void incUnsafe( int inc = 1 );
                 void incPoly( int inc = 1 );
                 void incSafe( int inc = 1 );
-  
+
                 Cost operator+( const Cost &other ) const;
                 Cost operator-( const Cost &other ) const;
@@ -36 +36 @@
                 bool operator!=( const Cost &other ) const;
                 friend std::ostream &operator<<( std::ostream &os, const Cost &cost );
-  
+
                 static const Cost zero;
                 static const Cost infinity;
+                static const Cost unsafe;
+                static const Cost poly;
+                static const Cost safe;
           private:
                 int compare( const Cost &other ) const;
 
-                int unsafe;
-                int poly;
-                int safe;
+                int unsafeCost;
+                int polyCost;
+                int safeCost;
         };
 
-        inline Cost::Cost() : unsafe( 0 ), poly( 0 ), safe( 0 ) {}
+        inline Cost::Cost() : unsafeCost( 0 ), polyCost( 0 ), safeCost( 0 ) {}
 
-        inline Cost::Cost( int unsafe, int poly, int safe ) : unsafe( unsafe ), poly( poly ), safe( safe ) {}
+        inline Cost::Cost( int unsafeCost, int polyCost, int safeCost ) : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ) {}
 
         inline void Cost::incUnsafe( int inc ) {
-                unsafe += inc;
+                unsafeCost += inc;
         }
 
         inline void Cost::incPoly( int inc ) {
-                poly += inc;
+                polyCost += inc;
         }
 
         inline void Cost::incSafe( int inc ) {
-                safe += inc;
+                safeCost += inc;
         }
 
         inline Cost Cost::operator+( const Cost &other ) const {
-                return Cost( unsafe + other.unsafe, poly + other.poly, safe + other.safe );
+                return Cost( unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost );
         }
 
         inline Cost Cost::operator-( const Cost &other ) const {
-                return Cost( unsafe - other.unsafe, poly - other.poly, safe - other.safe );
+                return Cost( unsafeCost - other.unsafeCost, polyCost - other.polyCost, safeCost - other.safeCost );
         }
 
         inline Cost &Cost::operator+=( const Cost &other ) {
-                unsafe += other.unsafe;
-                poly += other.poly;
-                safe += other.safe;
+                unsafeCost += other.unsafeCost;
+                polyCost += other.polyCost;
+                safeCost += other.safeCost;
                 return *this;
         }
 
         inline bool Cost::operator<( const Cost &other ) const {
-            if ( *this == infinity ) return false;
-            if ( other == infinity ) return true;
-            if ( unsafe > other.unsafe ) {
+                if ( *this == infinity ) return false;
+                if ( other == infinity ) return true;
+
+                if ( unsafeCost > other.unsafeCost ) {
                         return false;
-            } else if ( unsafe < other.unsafe ) {
+                } else if ( unsafeCost < other.unsafeCost ) {
                         return true;
-            } else if ( poly > other.poly ) {
+                } else if ( polyCost > other.polyCost ) {
                         return false;
-            } else if ( poly < other.poly ) {
+                } else if ( polyCost < other.polyCost ) {
                         return true;
-            } else if ( safe > other.safe ) {
+                } else if ( safeCost > other.safeCost ) {
                         return false;
-            } else if ( safe < other.safe ) {
+                } else if ( safeCost < other.safeCost ) {
                         return true;
-            } else {
+                } else {
                         return false;
-            } // if
+                } // if
         }
 
         inline bool Cost::operator==( const Cost &other ) const {
-                return unsafe == other.unsafe
-                        && poly == other.poly
-                        && safe == other.safe;
+                return unsafeCost == other.unsafeCost
+                        && polyCost == other.polyCost
+                        && safeCost == other.safeCost;
         }
 
@@ -109 +113 @@
 
         inline std::ostream &operator<<( std::ostream &os, const Cost &cost ) {
-                os << "( " << cost.unsafe << ", " << cost.poly << ", " << cost.safe << " )";
+                os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", " << cost.safeCost << " )";
                 return os;
         }