Changeset f80e0218 for src/Parser/ExpressionNode.cc

Timestamp:

Jun 30, 2016, 4:32:56 PM (9 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

ea29e73

Parents:

1b5c81ed (diff), 84d4d6f (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' into gc_noraii

Conflicts:

Jenkinsfile
src/SymTab/Validate.cc

File:

• src/Parser/ExpressionNode.cc (modified) (13 diffs)

src/Parser/ExpressionNode.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ExpressionNode.cc -- 
-// 
+// ExpressionNode.cc --
+//
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Apr  8 15:43:05 2016
-// Update Count     : 296
-// 
+// Last Modified On : Mon Jun 13 14:46:17 2016
+// Update Count     : 307
+//
 
 #include <cassert>
@@ -32 +32 @@
 using namespace std;
 
-ExpressionNode::ExpressionNode() : ParseNode(), argName( 0 ) {}
-
-ExpressionNode::ExpressionNode( const string *name ) : ParseNode( name ), argName( 0 ) {}
-
-ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.name ) {
+ExpressionNode::ExpressionNode() : ParseNode() {}
+
+ExpressionNode::ExpressionNode( const string *name ) : ParseNode( name ) {}
+
+ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.name ), extension( other.extension ) {
         if ( other.argName ) {
                 argName = other.argName->clone();
@@ -231 +231 @@
         // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string.
         value.insert( value.length() - 1, newValue->substr( 1, newValue->length() - 2 ) );
-        
+
         delete newValue;                                                                        // allocated by lexer
         return this;
@@ -344 +344 @@
 
 Expression *DesignatorNode::build() const {
-        Expression * ret = get_argName()->build();
+        Expression * ret = maybeBuild<Expression>(get_argName());
 
         if ( isArrayIndex ) {
-                // need to traverse entire structure and change any instances of 0 or 1 to 
+                // need to traverse entire structure and change any instances of 0 or 1 to
                 // ConstantExpr
                 DesignatorFixer fixer;
@@ -389 +389 @@
         "Cond", "NCond",
         // diadic
-        "SizeOf", "AlignOf", "OffsetOf", "Attr", "CompLit", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&",
+        "SizeOf", "AlignOf", "OffsetOf", "Attr", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&",
         "?|?", "?&?", "?^?", "Cast", "?<<?", "?>>?", "?<?", "?>?", "?<=?", "?>=?", "?==?", "?!=?",
         "?=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?",
@@ -440 +440 @@
 }
 
-CompositeExprNode::CompositeExprNode( const CompositeExprNode &other ) : ExpressionNode( other ), function( maybeClone( other.function ) ) {
+CompositeExprNode::CompositeExprNode( const CompositeExprNode &other ) : ExpressionNode( other ), function( maybeClone( other.function ) ), arguments( 0 ) {
         ParseNode *cur = other.arguments;
         while ( cur ) {
@@ -466 +466 @@
 
         if ( ! ( op = dynamic_cast<OperatorNode *>( function ) ) ) { // function as opposed to operator
-                return new UntypedExpr( function->build(), args, maybeBuild< Expression >( get_argName() ));
+                return new UntypedExpr( maybeBuild<Expression>(function), args, maybeBuild< Expression >( get_argName() ));
         } // if
 
@@ -550 +550 @@
                         if ( dynamic_cast< VoidType* >( targetType ) ) {
                                 delete targetType;
-                                return new CastExpr( expr_node->build(), maybeBuild< Expression >( get_argName() ) );
+                                return new CastExpr( maybeBuild<Expression>(expr_node), maybeBuild< Expression >( get_argName() ) );
                         } else {
-                                return new CastExpr( expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) );
+                                return new CastExpr( maybeBuild<Expression>(expr_node),targetType, maybeBuild< Expression >( get_argName() ) );
                         } // if
                 }
@@ -608 +608 @@
                 {
                         assert( args.size() == 2 );
-                        
+
                         if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args() ) ) {
                                 NameExpr *member = dynamic_cast<NameExpr *>( args.back() );
@@ -621 +621 @@
                         assert( var );
                         if ( ! get_args()->get_link() ) {
-                                return new AttrExpr( var->build(), ( Expression*)0);
+                                return new AttrExpr( maybeBuild<Expression>(var), ( Expression*)0);
                         } else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link()) ) {
-                                return new AttrExpr( var->build(), arg->get_decl()->buildType());
+                                return new AttrExpr( maybeBuild<Expression>(var), arg->get_decl()->buildType());
                         } else {
-                                return new AttrExpr( var->build(), args.back());
-                        } // if
-                }
-          case OperatorNode::CompLit:
-                throw UnimplementedError( "C99 compound literals" );
-                // the short-circuited operators
+                                return new AttrExpr( maybeBuild<Expression>(var), args.back());
+                        } // if
+                }
           case OperatorNode::Or:
           case OperatorNode::And:
@@ -719 +716 @@
 
 Expression *AsmExprNode::build() const {
-        return new AsmExpr( maybeBuild< Expression >( inout ), (ConstantExpr *)constraint->build(), operand->build() );
+        return new AsmExpr( maybeBuild< Expression >( inout ), (ConstantExpr *)maybeBuild<Expression>(constraint), maybeBuild<Expression>(operand) );
 }
 
@@ -796 +793 @@
 
 Expression *ValofExprNode::build() const {
-        return new UntypedValofExpr ( get_body()->build(), maybeBuild< Expression >( get_argName() ) );
+        return new UntypedValofExpr ( maybeBuild<Statement>(get_body()), maybeBuild< Expression >( get_argName() ) );
 }
 
@@ -908 +905 @@
 
 Expression *CompoundLiteralNode::build() const {
-        Declaration * newDecl = type->build();                          // compound literal type
+        Declaration * newDecl = maybeBuild<Declaration>(type); // compound literal type
         if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type
-                return new CompoundLiteralExpr( newDeclWithType->get_type(), kids->build() );
+                return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeBuild<Initializer>(kids) );
         // these types do not have associated type information
         } else if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( newDecl )  ) {
-                return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), kids->build() );
+                return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeBuild<Initializer>(kids) );
         } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl )  ) {
-                return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), kids->build() );
+                return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeBuild<Initializer>(kids) );
         } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl )  ) {
-                return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), kids->build() );
+                return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeBuild<Initializer>(kids) );
         } else {
                 assert( false );