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

File:

• src/Parser/ExpressionNode.cc (modified) (6 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 : Wed Aug 10 11:07:38 2016
-// Update Count     : 486
+// Last Modified On : Tue Aug  9 12:28:40 2016
+// Update Count     : 482
 //
 
@@ -168 +168 @@
 //##############################################################################
 
+//Expression *build_varref( ExpressionNode expr ) {
+//      return new NameExpr( get_name(), maybeBuild<Expression>( get_argName() ) );
+//}
+
+// VarRefNode::VarRefNode( const string *name, bool labelp ) : ExpressionNode( nullptr, name ), isLabel( labelp ) {}
+
+// VarRefNode::VarRefNode( const VarRefNode &other ) : ExpressionNode( other ), isLabel( other.isLabel ) {}
+
+// Expression *VarRefNode::build() const {
+//      return new NameExpr( get_name(), maybeBuild< Expression >( get_argName() ) );
+// }
+
+// void VarRefNode::printOneLine( std::ostream &os, int indent ) const {
+//      printDesignation( os );
+//      os << get_name() << ' ';
+// }
+
+// void VarRefNode::print( std::ostream &os, int indent ) const {
+//      printDesignation( os );
+//      os << string( indent, ' ' ) << "Referencing: ";
+//      os << "Variable: " << get_name();
+//      os << endl;
+// }
+
 NameExpr * build_varref( const string *name, bool labelp ) {
         return new NameExpr( *name, nullptr );
 }
+
+//##############################################################################
+
+// DesignatorNode::DesignatorNode( ExpressionNode *expr, bool isArrayIndex, bool isVarRef ) : isArrayIndex( isArrayIndex ) {
+//      set_argName( expr );
+// }
+
+// DesignatorNode::DesignatorNode( const DesignatorNode &other ) : ExpressionNode( other ), isArrayIndex( other.isArrayIndex ) {}
+
+// class DesignatorFixer : public Mutator {
+//   public:
+//      virtual Expression* mutate( NameExpr *nameExpr ) {
+//              if ( nameExpr->get_name() == "0" || nameExpr->get_name() == "1" ) {
+//                      Constant val( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nameExpr->get_name() );
+//                      delete nameExpr;
+//                      return new ConstantExpr( val );
+//              }
+//              return nameExpr;
+//      }
+// };
+
+// Expression *DesignatorNode::build() const {
+//      return maybeBuild<Expression>(get_argName());
+// }
+
+// void DesignatorNode::printOneLine( std::ostream &os, int indent ) const {
+//      if ( get_argName() ) {
+//              if ( isArrayIndex ) {
+//                      os << "[";
+//                      get_argName()->printOneLine( os, indent );
+//                      os << "]";
+//              } else {
+//                      os << ".";
+//                      get_argName()->printOneLine( os, indent );
+//              }
+//      } // if
+// }
+
+// void DesignatorNode::print( std::ostream &os, int indent ) const {
+//      if ( get_argName() ) {
+//              if ( isArrayIndex ) {
+//                      os << "[";
+//                      get_argName()->print( os, indent );
+//                      os << "]";
+//              } else {
+//                      os << ".";
+//                      get_argName()->print( os, indent );
+//              }
+//      } // if
+// }
 
 //##############################################################################
@@ -292 +366 @@
 //##############################################################################
 
+// Expression *AsmExprNode::build() const {
+//      return new AsmExpr( maybeBuild< Expression >( inout ), (ConstantExpr *)maybeBuild<Expression>(constraint), maybeBuild<Expression>(operand) );
+// }
+
+// void AsmExprNode::print( std::ostream &os, int indent ) const {
+//      os << string( indent, ' ' ) << "Assembler Expression:" << endl;
+//      if ( inout ) {
+//              os << string( indent, ' ' ) << "inout: " << std::endl;
+//              inout->print( os, indent + 2 );
+//      } // if
+//      if ( constraint ) {
+//              os << string( indent, ' ' ) << "constraint: " << std::endl;
+//              constraint->print( os, indent + 2 );
+//      } // if
+//      if ( operand ) {
+//              os << string( indent, ' ' ) << "operand: " << std::endl;
+//              operand->print( os, indent + 2 );
+//      } // if
+// }
+
+// void AsmExprNode::printOneLine( std::ostream &os, int indent ) const {
+//      printDesignation( os );
+//      os << "( ";
+//      if ( inout ) inout->printOneLine( os, indent + 2 );
+//      os << ", ";
+//      if ( constraint ) constraint->printOneLine( os, indent + 2 );
+//      os << ", ";
+//      if ( operand ) operand->printOneLine( os, indent + 2 );
+//      os << ") ";
+// }
+
 Expression *build_asm( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand ) {
         return new AsmExpr( maybeBuild< Expression >( inout ), constraint, maybeBuild<Expression>(operand) );
@@ -304 +409 @@
 //##############################################################################
 
+// ValofExprNode::ValofExprNode( StatementNode *s ): body( s ) {}
+
+// ValofExprNode::ValofExprNode( const ValofExprNode &other ) : ExpressionNode( other ), body( maybeClone( body ) ) {
+// }
+
+// ValofExprNode::~ValofExprNode() {
+//      delete body;
+// }
+
+// void ValofExprNode::print( std::ostream &os, int indent ) const {
+//      os << string( indent, ' ' ) << "Valof Expression:" << std::endl;
+//      get_body()->print( os, indent + 4);
+// }
+
+// void ValofExprNode::printOneLine( std::ostream &, int indent ) const {
+//      assert( false );
+// }
+
+// Expression *ValofExprNode::build() const {
+//      return new UntypedValofExpr( maybeBuild<Statement>(get_body()), nullptr );
+// }
+
 Expression *build_valexpr( StatementNode *s ) {
         return new UntypedValofExpr( maybeBuild<Statement>(s), nullptr );
@@ -309 +436 @@
 
 //##############################################################################
- 
-// 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 );
-// }
-
-//##############################################################################
+
+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 );
+}
+
+//##############################################################################
+
+// TypeValueNode::TypeValueNode( DeclarationNode *decl ) : decl( decl ) {
+// }
+
+// TypeValueNode::TypeValueNode( const TypeValueNode &other ) : ExpressionNode( other ), decl( maybeClone( other.decl ) ) {
+// }
+
+// Expression *TypeValueNode::build() const {
+//      return new TypeExpr( decl->buildType() );
+// }
+
+// void TypeValueNode::print( std::ostream &os, int indent ) const {
+//      os << std::string( indent, ' ' ) << "Type:";
+//      get_decl()->print( os, indent + 2);
+// }
+
+// void TypeValueNode::printOneLine( std::ostream &os, int indent ) const {
+//      os << "Type:";
+//      get_decl()->print( os, indent + 2);
+// }
 
 Expression *build_typevalue( DeclarationNode *decl ) {
@@ -368 +515 @@
 
 //##############################################################################
+
+// CompoundLiteralNode::CompoundLiteralNode( DeclarationNode *type, InitializerNode *kids ) : type( type ), kids( kids ) {}
+// CompoundLiteralNode::CompoundLiteralNode( const CompoundLiteralNode &other ) : ExpressionNode( other ), type( other.type ), kids( other.kids ) {}
+
+// CompoundLiteralNode::~CompoundLiteralNode() {
+//      delete kids;
+//      delete type;
+// }
+
+// CompoundLiteralNode *CompoundLiteralNode::clone() const {
+//      return new CompoundLiteralNode( *this );
+// }
+
+// void CompoundLiteralNode::print( std::ostream &os, int indent ) const {
+//      os << string( indent,' ' ) << "CompoundLiteralNode:" << endl;
+
+//      os << string( indent + 2, ' ' ) << "type:" << endl;
+//      if ( type != 0 )
+//              type->print( os, indent + 4 );
+
+//      os << string( indent + 2, ' ' ) << "initialization:" << endl;
+//      if ( kids != 0 )
+//              kids->printList( os, indent + 4 );
+// }
+
+// void CompoundLiteralNode::printOneLine( std::ostream &os, int indent ) const {
+//      os << "( ";
+//      if ( type ) type->print( os );
+//      os << ", ";
+//      if ( kids ) kids->printOneLine( os );
+//      os << ") ";
+// }
+
+// Expression *CompoundLiteralNode::build() const {
+//      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(), 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() ), maybeBuild<Initializer>(kids) );
+//      } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl )  ) {
+//              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() ), maybeBuild<Initializer>(kids) );
+//      } else {
+//              assert( false );
+//      } // if
+// }
 
 Expression *build_compoundLiteral( DeclarationNode *decl_node, InitializerNode *kids ) {