Changes in src/Parser/ExpressionNode.cc [0caaa6a:630a82a]

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 : Mon Jun 13 14:46:17 2016
-// Update Count     : 307
-//
+// Last Modified On : Fri Apr  8 15:43:05 2016
+// Update Count     : 296
+// 
 
 #include <cassert>
@@ -32 +32 @@
 using namespace std;
 
-ExpressionNode::ExpressionNode() : ParseNode() {}
-
-ExpressionNode::ExpressionNode( const string *name ) : ParseNode( name ) {}
-
-ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.name ), extension( other.extension ) {
+ExpressionNode::ExpressionNode() : ParseNode(), argName( 0 ) {}
+
+ExpressionNode::ExpressionNode( const string *name ) : ParseNode( name ), argName( 0 ) {}
+
+ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.name ) {
         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 = maybeBuild<Expression>(get_argName());
+        Expression * ret = get_argName()->build();
 
         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", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&",
+        "SizeOf", "AlignOf", "OffsetOf", "Attr", "CompLit", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&",
         "?|?", "?&?", "?^?", "Cast", "?<<?", "?>>?", "?<?", "?>?", "?<=?", "?>=?", "?==?", "?!=?",
         "?=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?",
@@ -440 +440 @@
 }
 
-CompositeExprNode::CompositeExprNode( const CompositeExprNode &other ) : ExpressionNode( other ), function( maybeClone( other.function ) ), arguments( 0 ) {
+CompositeExprNode::CompositeExprNode( const CompositeExprNode &other ) : ExpressionNode( other ), function( maybeClone( other.function ) ) {
         ParseNode *cur = other.arguments;
         while ( cur ) {
@@ -466 +466 @@
 
         if ( ! ( op = dynamic_cast<OperatorNode *>( function ) ) ) { // function as opposed to operator
-                return new UntypedExpr( maybeBuild<Expression>(function), args, maybeBuild< Expression >( get_argName() ));
+                return new UntypedExpr( function->build(), args, maybeBuild< Expression >( get_argName() ));
         } // if
 
@@ -550 +550 @@
                         if ( dynamic_cast< VoidType* >( targetType ) ) {
                                 delete targetType;
-                                return new CastExpr( maybeBuild<Expression>(expr_node), maybeBuild< Expression >( get_argName() ) );
+                                return new CastExpr( expr_node->build(), maybeBuild< Expression >( get_argName() ) );
                         } else {
-                                return new CastExpr( maybeBuild<Expression>(expr_node),targetType, maybeBuild< Expression >( get_argName() ) );
+                                return new CastExpr( expr_node->build(),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( maybeBuild<Expression>(var), ( Expression*)0);
+                                return new AttrExpr( var->build(), ( Expression*)0);
                         } else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link()) ) {
-                                return new AttrExpr( maybeBuild<Expression>(var), arg->get_decl()->buildType());
+                                return new AttrExpr( var->build(), arg->get_decl()->buildType());
                         } else {
-                                return new AttrExpr( maybeBuild<Expression>(var), args.back());
-                        } // if
-                }
+                                return new AttrExpr( var->build(), args.back());
+                        } // if
+                }
+          case OperatorNode::CompLit:
+                throw UnimplementedError( "C99 compound literals" );
+                // the short-circuited operators
           case OperatorNode::Or:
           case OperatorNode::And:
@@ -716 +719 @@
 
 Expression *AsmExprNode::build() const {
-        return new AsmExpr( maybeBuild< Expression >( inout ), (ConstantExpr *)maybeBuild<Expression>(constraint), maybeBuild<Expression>(operand) );
+        return new AsmExpr( maybeBuild< Expression >( inout ), (ConstantExpr *)constraint->build(), operand->build() );
 }
 
@@ -793 +796 @@
 
 Expression *ValofExprNode::build() const {
-        return new UntypedValofExpr ( maybeBuild<Statement>(get_body()), maybeBuild< Expression >( get_argName() ) );
+        return new UntypedValofExpr ( get_body()->build(), maybeBuild< Expression >( get_argName() ) );
 }
 
@@ -905 +908 @@
 
 Expression *CompoundLiteralNode::build() const {
-        Declaration * newDecl = maybeBuild<Declaration>(type); // compound literal type
+        Declaration * newDecl = type->build();                          // compound literal type
         if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type
-                return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeBuild<Initializer>(kids) );
+                return new CompoundLiteralExpr( newDeclWithType->get_type(), kids->build() );
         // 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() ), maybeBuild<Initializer>(kids) );
+                return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), kids->build() );
         } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl )  ) {
-                return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeBuild<Initializer>(kids) );
+                return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), kids->build() );
         } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl )  ) {
-                return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeBuild<Initializer>(kids) );
+                return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), kids->build() );
         } else {
                 assert( false );