Changeset 5b51f5e for src/SynTree

Timestamp:

Jan 5, 2018, 3:21:42 PM (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:

65deb18, cae28da

Parents:

5c4f2c2 (diff), b834e98 (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

Location:

src/SynTree

Files:

• AggregateDecl.cc (modified) (1 diff)
• Declaration.h (modified) (1 diff)
• Expression.cc (modified) (2 diffs)
• Expression.h (modified) (1 diff)
• Type.h (modified) (1 diff)

src/SynTree/AggregateDecl.cc

@@ -86 +86 @@
 std::string TraitDecl::typeString() const { return "trait"; }
 
+namespace {
+        long long int getConstValue( Expression * expr ) {
+                if ( CastExpr * castExpr = dynamic_cast< CastExpr * > ( expr ) ) {
+                        return getConstValue( castExpr->arg );
+                } else if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) {
+                        return constExpr->intValue();
+                } else {
+                        assertf( false, "Unhandled expression type in getConstValue for enumerators: %s", toString( expr ).c_str() );
+                }
+        }
+}
+
+bool EnumDecl::valueOf( Declaration * enumerator, long long int & value ) {
+        if ( enumValues.empty() ) {
+                long long int currentValue = 0;
+                for ( Declaration * member : members ) {
+                        ObjectDecl * field = strict_dynamic_cast< ObjectDecl * >( member );
+                        if ( field->init ) {
+                                SingleInit * init = strict_dynamic_cast< SingleInit * >( field->init );
+                                currentValue = getConstValue( init->value );
+                        }
+                        assertf( enumValues.count( field->name ) == 0, "Enum %s has multiple members with the name %s", name.c_str(), field->name.c_str() );
+                        enumValues[ field->name ] = currentValue;
+                        ++currentValue;
+                }
+        }
+        if ( enumValues.count( enumerator->name ) ) {
+                value = enumValues[ enumerator->name ];
+                return true;
+        }
+        return false;
+}
+
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Declaration.h

@@ -319 +319 @@
         EnumDecl( const EnumDecl &other ) : Parent( other ) {}
 
+        bool valueOf( Declaration * enumerator, long long int & value );
+
         virtual EnumDecl *clone() const override { return new EnumDecl( *this ); }
         virtual void accept( Visitor &v ) override { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
   private:
+        std::map< std::string, long long int > enumValues;
         virtual std::string typeString() const override;
 };

src/SynTree/Expression.cc

@@ -83 +83 @@
 }
 
+long long int ConstantExpr::intValue() const {
+        if ( BasicType * basicType = dynamic_cast< BasicType * >( result ) ) {
+                if ( basicType->isInteger() ) {
+                        return get_constant()->get_ival();
+                }
+        } else if ( dynamic_cast< OneType * >( result ) ) {
+                return 1;
+        } else if ( dynamic_cast< ZeroType * >( result ) ) {
+                return 0;
+        }
+        throw SemanticError( "Constant expression of non-integral type ", this );
+}
+
 VariableExpr::VariableExpr( DeclarationWithType *_var ) : Expression(), var( _var ) {
         assert( var );
@@ -589 +602 @@
         if ( ! body.empty() ) {
                 if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( body.back() ) ) {
-                        set_result( maybeClone( exprStmt->get_expr()->get_result() ) );
+                        result = maybeClone( exprStmt->expr->result );
                 }
         }
         // ensure that StmtExpr has a result type
         if ( ! result ) {
-                set_result( new VoidType( Type::Qualifiers() ) );
+                result = new VoidType( Type::Qualifiers() );
         }
 }

src/SynTree/Expression.h

@@ -295 +295 @@
 
         Constant * get_constant() { return & constant; }
+        const Constant * get_constant() const { return & constant; }
         void set_constant( const Constant & newValue ) { constant = newValue; }
+
+        long long int intValue() const;
 
         virtual ConstantExpr * clone() const { return new ConstantExpr( * this ); }

src/SynTree/Type.h

@@ -356 +356 @@
         bool isTtype() const;
 
+        bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
+
         virtual FunctionType *clone() const override { return new FunctionType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }