Changeset 9706554 for src/Parser/ExpressionNode.cc

Timestamp:

Aug 5, 2016, 12:06:21 PM (8 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:

71a3593

Parents:

51e076e

Message:

even more refactoring of parser code

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 : Fri Aug  5 07:56:23 2016
-// Update Count     : 375
+// Last Modified On : Fri Aug  5 11:39:25 2016
+// Update Count     : 391
 //
 
@@ -289 +289 @@
 }
 
-CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2):
+CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2 ):
         function( f ), arguments( arg1 ) {
         arguments->set_link( arg2 );
@@ -369 +369 @@
 }
 
-Expression *build_opr1( OperatorNode::Type op, ExpressionNode *expr_node ) {
+Expression *build_unary_val( OperatorNode::Type op, ExpressionNode *expr_node ) {
+        std::list<Expression *> args;
+        args.push_back( maybeBuild<Expression>(expr_node) );
+        return new UntypedExpr( new NameExpr( opName[ op ] ), args );
+}
+Expression *build_unary_ptr( OperatorNode::Type op, ExpressionNode *expr_node ) {
         std::list<Expression *> args;
         args.push_back( new AddressExpr( maybeBuild<Expression>(expr_node) ) );
         return new UntypedExpr( new NameExpr( opName[ op ] ), args );
 }
-Expression *build_opr2( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
+Expression *build_binary_val( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
         std::list<Expression *> args;
         args.push_back( maybeBuild<Expression>(expr_node1) );
@@ -380 +385 @@
         return new UntypedExpr( new NameExpr( opName[ op ] ), args );
 }
+Expression *build_binary_ptr( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *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( opName[ op ] ), args );
+}
 
 Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 ) {
@@ -387 +398 @@
 Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
         return new CommaExpr( maybeBuild<Expression>(expr_node1), maybeBuild<Expression>(expr_node2) );
+}
+
+Expression *build_attr( VarRefNode *var, ExpressionNode * expr ) {
+        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( expr ) ) {
+                return new AttrExpr( maybeBuild<Expression>(var), arg->get_decl()->buildType() );
+        } else {
+                return new AttrExpr( maybeBuild<Expression>(var), maybeBuild<Expression>(expr) );
+        } // if
+}
+
+Expression *build_tuple( ExpressionNode * expr ) {
+        TupleExpr *ret = new TupleExpr();
+        buildList( expr, ret->get_exprs() );
+        return ret;
+}
+
+Expression *build_func( ExpressionNode * function, ExpressionNode * expr ) {
+        std::list<Expression *> args;
+
+        buildList( expr, args );
+        return new UntypedExpr( maybeBuild<Expression>(function), args, nullptr );
 }
 
@@ -406 +438 @@
         } // if
 
-        switch ( op->get_type() ) {
-          case OperatorNode::Assign:
-          case OperatorNode::MulAssn:
-          case OperatorNode::DivAssn:
-          case OperatorNode::ModAssn:
-          case OperatorNode::PlusAssn:
-          case OperatorNode::MinusAssn:
-          case OperatorNode::LSAssn:
-          case OperatorNode::RSAssn:
-          case OperatorNode::AndAssn:
-          case OperatorNode::ERAssn:
-          case OperatorNode::OrAssn:
-                assert( ! args.empty() );
-                args.front() = new AddressExpr( args.front() );
-          case OperatorNode::UnPlus:
-          case OperatorNode::UnMinus:
-          case OperatorNode::PointTo:
-          case OperatorNode::Neg:
-          case OperatorNode::BitNeg:
-          case OperatorNode::LabelAddress:
-                return new UntypedExpr( new NameExpr( opName[ op->get_type() ] ), args );
-
-          case OperatorNode::Attr:
-                {
-                        VarRefNode *var = dynamic_cast<VarRefNode *>( get_args() );
-                        assert( var );
-                        if ( ! get_args()->get_link() ) {
-                                return new AttrExpr( maybeBuild<Expression>(var), ( Expression*)0);
-                        } else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link() ) ) {
-                                return new AttrExpr( maybeBuild<Expression>(var), arg->get_decl()->buildType() );
-                        } else {
-                                return new AttrExpr( maybeBuild<Expression>(var), args.back() );
-                        } // if
-                }
-          case OperatorNode::Cond:
-                {
-                        assert( args.size() == 3);
-                        std::list< Expression * >::const_iterator i = args.begin();
-                        Expression *arg1 = notZeroExpr( *i++ );
-                        Expression *arg2 = *i++;
-                        Expression *arg3 = *i++;
-                        return new ConditionalExpr( arg1, arg2, arg3 );
-                }
-          case OperatorNode::NCond:
-                throw UnimplementedError( "GNU 2-argument conditional expression" );
-                // Tuples
-          case OperatorNode::TupleC:
-                {
-                        TupleExpr *ret = new TupleExpr();
-                        std::copy( args.begin(), args.end(), back_inserter( ret->get_exprs() ) );
-                        return ret;
-                }
-          default:
-                assert( ((void)"CompositeExprNode::build", false) );
-                return 0;
-        } // switch
+        assert( ((void)"CompositeExprNode::build", false) );
+        return nullptr;
 }