Changeset 064e3ff for src/Parser/ExpressionNode.cc

Timestamp:

Aug 4, 2016, 5:26:08 PM (9 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, 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:

b87e2b60

Parents:

76e8c55

Message:

add new type for ranges and refactor parser code

File:

• src/Parser/ExpressionNode.cc (modified) (5 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 : Tue Aug  2 15:10:23 2016
-// Update Count     : 322
+// Last Modified On : Thu Aug  4 16:11:23 2016
+// Update Count     : 338
 //
 
@@ -258 +258 @@
 OperatorNode::~OperatorNode() {}
 
-OperatorNode::Type OperatorNode::get_type( void ) const{
+OperatorNode::Type OperatorNode::get_type( void ) const {
         return type;
 }
@@ -311 +311 @@
 }
 
-#include "Common/utility.h"
+
+Expression *build_cast( TypeValueNode * arg, ExpressionNode *expr_node ) {
+        DeclarationNode *decl_node = arg->get_decl();
+
+        Type *targetType = decl_node->buildType();
+        if ( dynamic_cast< VoidType* >( targetType ) ) {
+                delete targetType;
+                return new CastExpr( maybeBuild<Expression>(expr_node) );
+        } else {
+                return new CastExpr( maybeBuild<Expression>(expr_node), targetType );
+        } // if
+}
+
+Expression *build_fieldSel( ExpressionNode *expr_node, VarRefNode *member ) {
+        NameExpr* memberExpr = dynamic_cast<NameExpr*> ( maybeBuild<Expression>( member) );
+        assert( memberExpr );
+        UntypedMemberExpr *ret = new UntypedMemberExpr( memberExpr->get_name(), maybeBuild<Expression>(expr_node) );
+        delete member;
+        return ret;
+}
+
+Expression *build_pfieldSel( ExpressionNode *expr_node, VarRefNode *member ) {
+        NameExpr* memberExpr = dynamic_cast<NameExpr*> ( maybeBuild<Expression>( member) );
+        assert( memberExpr );
+        UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
+        deref->get_args().push_back( maybeBuild<Expression>(expr_node) );
+        UntypedMemberExpr *ret = new UntypedMemberExpr( memberExpr->get_name(), deref );
+        delete member;
+        return ret;
+}
+
+Expression *build_addressOf( ExpressionNode *expr_node ) {
+                return new AddressExpr( maybeBuild<Expression>(expr_node) );
+}
+Expression *build_sizeOf( ExpressionNode *expr_node ) {
+        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( expr_node ) ) {
+                return new SizeofExpr( arg->get_decl()->buildType() );
+        } else {
+                return new SizeofExpr( maybeBuild<Expression>(expr_node) );
+        } // if
+}
+Expression *build_alignOf( ExpressionNode *expr_node ) {
+        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( expr_node ) ) {
+                return new AlignofExpr( arg->get_decl()->buildType() );
+        } else {
+                return new AlignofExpr( maybeBuild<Expression>(expr_node) );
+        } // if
+}
+Expression *build_offsetOf( TypeValueNode * arg, VarRefNode *member ) {
+        NameExpr *memberExpr = dynamic_cast<NameExpr *>( maybeBuild<Expression>( member ) );
+        assert( memberExpr );
+        return new UntypedOffsetofExpr( arg->get_decl()->buildType(), memberExpr->get_name() );
+}
+
+CompositeExprNode2::CompositeExprNode2( Expression *expr ) : expr( expr ) {}
+CompositeExprNode2::CompositeExprNode2( const CompositeExprNode2 &other ) : expr( other.expr->clone() ) {}
+CompositeExprNode2::~CompositeExprNode2() { delete expr; }
+void CompositeExprNode2::print( std::ostream &, int indent ) const { assert( false ); }
+void CompositeExprNode2::printOneLine( std::ostream &, int indent ) const { assert( false ); }
+
 
 Expression *CompositeExprNode::build() const {
@@ -388 +447 @@
           case OperatorNode::LabelAddress:
                 return new UntypedExpr( new NameExpr( opName[ op->get_type() ] ), args );
-          case OperatorNode::AddressOf:
-                assert( args.size() == 1 );
-                assert( args.front() );
-
-                return new AddressExpr( args.front() );
-          case OperatorNode::Cast:
-                {
-                        TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args());
-                        assert( arg );
-
-                        DeclarationNode *decl_node = arg->get_decl();
-                        ExpressionNode *expr_node = dynamic_cast<ExpressionNode *>( arg->get_link());
-
-                        Type *targetType = decl_node->buildType();
-                        if ( dynamic_cast< VoidType* >( targetType ) ) {
-                                delete targetType;
-                                return new CastExpr( maybeBuild<Expression>(expr_node), maybeBuild< Expression >( get_argName() ) );
-                        } else {
-                                return new CastExpr( maybeBuild<Expression>(expr_node),targetType, maybeBuild< Expression >( get_argName() ) );
-                        } // if
-                }
-          case OperatorNode::FieldSel:
-                {
-                        assert( args.size() == 2 );
-
-                        NameExpr *member = dynamic_cast<NameExpr *>( args.back());
-                        // TupleExpr *memberTup = dynamic_cast<TupleExpr *>( args.back());
-
-                        if ( member != 0 ) {
-                                UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), args.front());
-                                delete member;
-                                return ret;
-                                /* else if ( memberTup != 0 )
-                                   {
-                                   UntypedMemberExpr *ret = new UntypedMemberExpr( memberTup->get_name(), args.front());
-                                   delete member;
-                                   return ret;
-                                   } */
-                        } else
-                                assert( false );
-                }
-          case OperatorNode::PFieldSel:
-                {
-                        assert( args.size() == 2 );
-
-                        NameExpr *member = dynamic_cast<NameExpr *>( args.back());  // modify for Tuples   xxx
-                        assert( member != 0 );
-
-                        UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-                        deref->get_args().push_back( args.front() );
-
-                        UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref );
-                        delete member;
-                        return ret;
-                }
-          case OperatorNode::SizeOf:
-                {
-                        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
-                                return new SizeofExpr( arg->get_decl()->buildType());
-                        } else {
-                                return new SizeofExpr( args.front());
-                        } // if
-                }
-          case OperatorNode::AlignOf:
-                {
-                        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
-                                return new AlignofExpr( arg->get_decl()->buildType());
-                        } else {
-                                return new AlignofExpr( args.front());
-                        } // if
-                }
-          case OperatorNode::OffsetOf:
-                {
-                        assert( args.size() == 2 );
-
-                        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args() ) ) {
-                                NameExpr *member = dynamic_cast<NameExpr *>( args.back() );
-                                assert( member != 0 );
-
-                                return new UntypedOffsetofExpr( arg->get_decl()->buildType(), member->get_name() );
-                        } else assert( false );
-                }
           case OperatorNode::Attr:
                 {
@@ -774 +751 @@
 }
 
-
 ExpressionNode *flattenCommas( ExpressionNode *list ) {
         if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) {