Changes in src/Parser/ExpressionNode.cc [a839867:2f22cc4]

File:

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

src/Parser/ExpressionNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 25 21:39:40 2016
-// Update Count     : 503
+// Last Modified On : Wed Aug 10 11:07:38 2016
+// Update Count     : 486
 //
 
@@ -32 +32 @@
 using namespace std;
 
-ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.get_name() ), extension( other.extension ) {}
+ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.name ), extension( other.extension ) {}
 
 //##############################################################################
@@ -57 +57 @@
 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
 
-Expression *build_constantInteger( const std::string & str ) {
+Expression *build_constantInteger( std::string & str ) {
         static const BasicType::Kind kind[2][3] = {
                 { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
@@ -120 +120 @@
         } // if
 
-        Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str ) );
-        delete &str;                                                                            // created by lex
-        return ret;
+        return new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str ) );
 } // build_constantInteger
 
-Expression *build_constantFloat( const std::string & str ) {
+Expression *build_constantFloat( std::string & str ) {
         static const BasicType::Kind kind[2][3] = {
                 { BasicType::Float, BasicType::Double, BasicType::LongDouble },
@@ -152 +150 @@
         } // if
 
-        Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str ) );
-        delete &str;                                                                            // created by lex
-        return ret;
+        return new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str ) );
 } // build_constantFloat
 
-Expression *build_constantChar( const std::string & str ) {
-        Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str ) );
-        delete &str;                                                                            // created by lex
-        return ret;
+Expression *build_constantChar( std::string & str ) {
+        return new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str ) );
 } // build_constantChar
 
-ConstantExpr *build_constantStr( const std::string & str ) {
+ConstantExpr *build_constantStr( std::string & str ) {
         // string should probably be a primitive type
         ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( emptyQualifiers, BasicType::Char ),
@@ -169 +163 @@
                                                                                         toString( str.size()+1-2 ) ) ),  // +1 for '\0' and -2 for '"'
                                                                    false, false );
-        ConstantExpr * ret = new ConstantExpr( Constant( at, str ) );
-        delete &str;                                                                            // created by lex
-        return ret;
+        return new ConstantExpr( Constant( at, str ) );
 } // build_constantStr
 
+//##############################################################################
+
 NameExpr * build_varref( const string *name, bool labelp ) {
-        NameExpr *expr = new NameExpr( *name, nullptr );
-        delete name;
-        return expr;
-}
+        return new NameExpr( *name, nullptr );
+}
+
+//##############################################################################
 
 static const char *OperName[] = {
@@ -184 +178 @@
         "SizeOf", "AlignOf", "OffsetOf", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&",
         "?|?", "?&?", "?^?", "Cast", "?<<?", "?>>?", "?<?", "?>?", "?<=?", "?>=?", "?==?", "?!=?",
-        "?=?", "?@=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?",
+        "?=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?",
         "?[?]", "...",
         // monadic
@@ -190 +184 @@
 };
 
+//##############################################################################
+
 Expression *build_cast( DeclarationNode *decl_node, ExpressionNode *expr_node ) {
-        Type *targetType = maybeMoveBuildType( decl_node );
+        Type *targetType = decl_node->buildType();
         if ( dynamic_cast< VoidType * >( targetType ) ) {
                 delete targetType;
-                return new CastExpr( maybeMoveBuild< Expression >(expr_node) );
+                return new CastExpr( maybeBuild<Expression>(expr_node) );
         } else {
-                return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType );
+                return new CastExpr( maybeBuild<Expression>(expr_node), targetType );
         } // if
 }
 
 Expression *build_fieldSel( ExpressionNode *expr_node, NameExpr *member ) {
-        UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), maybeMoveBuild< Expression >(expr_node) );
+        UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), maybeBuild<Expression>(expr_node) );
         delete member;
         return ret;
@@ -208 +204 @@
 Expression *build_pfieldSel( ExpressionNode *expr_node, NameExpr *member ) {
         UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-        deref->get_args().push_back( maybeMoveBuild< Expression >(expr_node) );
+        deref->get_args().push_back( maybeBuild<Expression>(expr_node) );
         UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref );
         delete member;
@@ -215 +211 @@
 
 Expression *build_addressOf( ExpressionNode *expr_node ) {
-                return new AddressExpr( maybeMoveBuild< Expression >(expr_node) );
+                return new AddressExpr( maybeBuild<Expression>(expr_node) );
 }
 Expression *build_sizeOfexpr( ExpressionNode *expr_node ) {
-        return new SizeofExpr( maybeMoveBuild< Expression >(expr_node) );
+        return new SizeofExpr( maybeBuild<Expression>(expr_node) );
 }
 Expression *build_sizeOftype( DeclarationNode *decl_node ) {
-        return new SizeofExpr( maybeMoveBuildType( decl_node ) );
+        return new SizeofExpr( decl_node->buildType() );
 }
 Expression *build_alignOfexpr( ExpressionNode *expr_node ) {
-        return new AlignofExpr( maybeMoveBuild< Expression >(expr_node) );
+        return new AlignofExpr( maybeBuild<Expression>(expr_node) );
 }
 Expression *build_alignOftype( DeclarationNode *decl_node ) {
-        return new AlignofExpr( maybeMoveBuildType( decl_node) );
+        return new AlignofExpr( decl_node->buildType() );
 }
 Expression *build_offsetOf( DeclarationNode *decl_node, NameExpr *member ) {
-        Expression* ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() );
-        delete member;
-        return ret;
+        return new UntypedOffsetofExpr( decl_node->buildType(), member->get_name() );
 }
 
 Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind ) {
-        return new LogicalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), notZeroExpr( maybeMoveBuild< Expression >(expr_node2) ), kind );
+        return new LogicalExpr( notZeroExpr( maybeBuild<Expression>(expr_node1) ), notZeroExpr( maybeBuild<Expression>(expr_node2) ), kind );
 }
 
 Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node ) {
-        std::list< Expression * > args;
-        args.push_back( maybeMoveBuild< Expression >(expr_node) );
+        std::list<Expression *> args;
+        args.push_back( maybeBuild<Expression>(expr_node) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 }
 Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node ) {
-        std::list< Expression * > args;
-        args.push_back( new AddressExpr( maybeMoveBuild< Expression >(expr_node) ) );
+        std::list<Expression *> args;
+        args.push_back( new AddressExpr( maybeBuild<Expression>(expr_node) ) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 }
 Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
-        std::list< Expression * > args;
-        args.push_back( maybeMoveBuild< Expression >(expr_node1) );
-        args.push_back( maybeMoveBuild< Expression >(expr_node2) );
+        std::list<Expression *> args;
+        args.push_back( maybeBuild<Expression>(expr_node1) );
+        args.push_back( maybeBuild<Expression>(expr_node2) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 }
 Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
-        std::list< Expression * > args;
-        args.push_back( new AddressExpr( maybeMoveBuild< Expression >(expr_node1) ) );
-        args.push_back( maybeMoveBuild< Expression >(expr_node2) );
+        std::list<Expression *> args;
+        args.push_back( new AddressExpr( maybeBuild<Expression>(expr_node1) ) );
+        args.push_back( maybeBuild<Expression>(expr_node2) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 }
 
 Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 ) {
-        return new ConditionalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), maybeMoveBuild< Expression >(expr_node2), maybeMoveBuild< Expression >(expr_node3) );
+        return new ConditionalExpr( notZeroExpr( maybeBuild<Expression>(expr_node1) ), maybeBuild<Expression>(expr_node2), maybeBuild<Expression>(expr_node3) );
 }
 
 Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
-        return new CommaExpr( maybeMoveBuild< Expression >(expr_node1), maybeMoveBuild< Expression >(expr_node2) );
+        return new CommaExpr( maybeBuild<Expression>(expr_node1), maybeBuild<Expression>(expr_node2) );
 }
 
 Expression *build_attrexpr( NameExpr *var, ExpressionNode * expr_node ) {
-        return new AttrExpr( var, maybeMoveBuild< Expression >(expr_node) );
+        return new AttrExpr( var, maybeBuild<Expression>(expr_node) );
 }
 Expression *build_attrtype( NameExpr *var, DeclarationNode * decl_node ) {
-        return new AttrExpr( var, maybeMoveBuildType( decl_node ) );
+        return new AttrExpr( var, decl_node->buildType() );
 }
 
 Expression *build_tuple( ExpressionNode * expr_node ) {
         TupleExpr *ret = new TupleExpr();
-        buildMoveList( expr_node, ret->get_exprs() );
+        buildList( expr_node, ret->get_exprs() );
         return ret;
 }
 
 Expression *build_func( ExpressionNode * function, ExpressionNode * expr_node ) {
-        std::list< Expression * > args;
-        buildMoveList( expr_node, args );
-        return new UntypedExpr( maybeMoveBuild< Expression >(function), args, nullptr );
+        std::list<Expression *> args;
+
+        buildList( expr_node, args );
+        return new UntypedExpr( maybeBuild<Expression>(function), args, nullptr );
 }
 
 Expression *build_range( ExpressionNode * low, ExpressionNode *high ) {
-        return new RangeExpr( maybeMoveBuild< Expression >( low ), maybeMoveBuild< Expression >( high ) );
-}
-
-Expression *build_asmexpr( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand ) {
-        return new AsmExpr( maybeMoveBuild< Expression >( inout ), constraint, maybeMoveBuild< Expression >(operand) );
-}
+        Expression *low_cexpr = maybeBuild<Expression>( low );
+        Expression *high_cexpr = maybeBuild<Expression>( high );
+        return new RangeExpr( low_cexpr, high_cexpr );
+}
+
+//##############################################################################
+
+Expression *build_asm( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand ) {
+        return new AsmExpr( maybeBuild< Expression >( inout ), constraint, maybeBuild<Expression>(operand) );
+}
+
+//##############################################################################
+
+void LabelNode::print( std::ostream &os, int indent ) const {}
+
+void LabelNode::printOneLine( std::ostream &os, int indent ) const {}
+
+//##############################################################################
 
 Expression *build_valexpr( StatementNode *s ) {
-        return new UntypedValofExpr( maybeMoveBuild< Statement >(s), nullptr );
-}
+        return new UntypedValofExpr( maybeBuild<Statement>(s), nullptr );
+}
+
+//##############################################################################
+ 
+// ForCtlExprNode::ForCtlExprNode( ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr ) throw ( SemanticError ) : condition( cond ), change( incr ) {
+//      if ( init_ == 0 )
+//              init = 0;
+//      else {
+//              DeclarationNode *decl;
+//              ExpressionNode *exp;
+
+//              if (( decl = dynamic_cast<DeclarationNode *>(init_) ) != 0)
+//                      init = new StatementNode( decl );
+//              else if (( exp = dynamic_cast<ExpressionNode *>( init_)) != 0)
+//                      init = new StatementNode( StatementNode::Exp, exp );
+//              else
+//                      throw SemanticError("Error in for control expression");
+//      }
+// }
+
+// ForCtlExprNode::ForCtlExprNode( const ForCtlExprNode &other )
+//      : ExpressionNode( other ), init( maybeClone( other.init ) ), condition( maybeClone( other.condition ) ), change( maybeClone( other.change ) ) {
+// }
+
+// ForCtlExprNode::~ForCtlExprNode() {
+//      delete init;
+//      delete condition;
+//      delete change;
+// }
+
+// Expression *ForCtlExprNode::build() const {
+//      // this shouldn't be used!
+//      assert( false );
+//      return 0;
+// }
+
+// void ForCtlExprNode::print( std::ostream &os, int indent ) const{
+//      os << string( indent,' ' ) << "For Control Expression -- :" << endl;
+
+//      os << string( indent + 2, ' ' ) << "initialization:" << endl;
+//      if ( init != 0 )
+//              init->printList( os, indent + 4 );
+
+//      os << string( indent + 2, ' ' ) << "condition: " << endl;
+//      if ( condition != 0 )
+//              condition->print( os, indent + 4 );
+//      os << string( indent + 2, ' ' ) << "increment: " << endl;
+//      if ( change != 0 )
+//              change->print( os, indent + 4 );
+// }
+
+// void ForCtlExprNode::printOneLine( std::ostream &, int indent ) const {
+//      assert( false );
+// }
+
+//##############################################################################
+
 Expression *build_typevalue( DeclarationNode *decl ) {
-        return new TypeExpr( maybeMoveBuildType( decl ) );
-}
+        return new TypeExpr( decl->buildType() );
+}
+
+//##############################################################################
 
 Expression *build_compoundLiteral( DeclarationNode *decl_node, InitializerNode *kids ) {
-        Declaration * newDecl = maybeBuild< Declaration >(decl_node); // compound literal type
+        Declaration * newDecl = maybeBuild<Declaration>(decl_node); // compound literal type
         if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type
-                return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeMoveBuild< Initializer >(kids) );
+                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() ), maybeMoveBuild< Initializer >(kids) );
+                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() ), maybeMoveBuild< Initializer >(kids) );
+                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() ), maybeMoveBuild< Initializer >(kids) );
+                return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeBuild<Initializer>(kids) );
         } else {
                 assert( false );