Changeset d9e2280 for src/Parser/ExpressionNode.cc

Timestamp:

Aug 5, 2016, 3:56:24 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:

35f9114

Parents:

71a3593

Message:

even more more refactoring of 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 : Fri Aug  5 11:39:25 2016
-// Update Count     : 391
+// Last Modified On : Fri Aug  5 15:07:19 2016
+// Update Count     : 409
 //
 
@@ -238 +238 @@
 //##############################################################################
 
-static const char *opName[] = {
-        "TupleC", "Comma", "TupleFieldSel", // "TuplePFieldSel", // n-adic
-        // triadic
-        "Cond", "NCond",
+static const char *OperName[] = {
         // diadic
         "SizeOf", "AlignOf", "OffsetOf", "Attr", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&",
         "?|?", "?&?", "?^?", "Cast", "?<<?", "?>>?", "?<?", "?>?", "?<=?", "?>=?", "?==?", "?!=?",
         "?=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?",
-        "?[?]", "FieldSel", "PFieldSel", "...",
+        "?[?]", "...",
         // monadic
         "+?", "-?", "AddressOf", "*?", "!?", "~?", "++?", "?++", "--?", "?--", "&&"
 };
 
-OperatorNode::OperatorNode( Type t ) : type( t ) {}
-
-OperatorNode::OperatorNode( const OperatorNode &other ) : ExpressionNode( other ), type( other.type ) {
-}
-
-OperatorNode::~OperatorNode() {}
-
-OperatorNode::Type OperatorNode::get_type( void ) const {
-        return type;
-}
-
-void OperatorNode::printOneLine( std::ostream &os, int indent ) const {
-        printDesignation( os );
-        os << opName[ type ] << ' ';
-}
-
-void OperatorNode::print( std::ostream &os, int indent ) const{
-        printDesignation( os );
-        os << string( indent, ' ' ) << "Operator: " << opName[type] << endl;
-        return;
-}
-
-const char *OperatorNode::get_typename( void ) const{
-        return opName[ type ];
-}
-
-//##############################################################################
-
-CompositeExprNode::CompositeExprNode() : ExpressionNode(), function( 0 ), arguments( 0 ) {
-}
-
-CompositeExprNode::CompositeExprNode( const string *name_ ) : ExpressionNode( name_ ), function( 0 ), arguments( 0 ) {
-}
-
-CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *args ):
-        function( f ), arguments( args ) {
-}
-
-CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2 ):
-        function( f ), arguments( arg1 ) {
-        arguments->set_link( arg2 );
-}
-
-CompositeExprNode::CompositeExprNode( const CompositeExprNode &other ) : ExpressionNode( other ), function( maybeClone( other.function ) ), arguments( 0 ) {
-        ParseNode *cur = other.arguments;
-        while ( cur ) {
-                if ( arguments ) {
-                        arguments->set_link( cur->clone() );
-                } else {
-                        arguments = ( ExpressionNode*)cur->clone();
-                } // if
-                cur = cur->get_link();
-        }
-}
-
-CompositeExprNode::~CompositeExprNode() {
-        delete function;
-        delete arguments;
-}
-
+//##############################################################################
+
+CompositeExprNode::CompositeExprNode( Expression *expr ) : expr( expr ) {}
+CompositeExprNode::CompositeExprNode( const CompositeExprNode &other ) : expr( other.expr->clone() ) {}
+CompositeExprNode::~CompositeExprNode() { delete expr; }
+void CompositeExprNode::print( std::ostream &, int indent ) const { assert( false ); }
+void CompositeExprNode::printOneLine( std::ostream &, int indent ) const { assert( false ); }
 
 Expression *build_cast( TypeValueNode * arg, ExpressionNode *expr_node ) {
@@ -369 +313 @@
 }
 
-Expression *build_unary_val( OperatorNode::Type op, ExpressionNode *expr_node ) {
+Expression *build_unary_val( OperKinds 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 ) {
+        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( maybeBuild<Expression>(expr_node) ) );
-        return new UntypedExpr( new NameExpr( opName[ op ] ), args );
-}
-Expression *build_binary_val( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
+        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( maybeBuild<Expression>(expr_node1) );
         args.push_back( maybeBuild<Expression>(expr_node2) );
-        return new UntypedExpr( new NameExpr( opName[ op ] ), args );
-}
-Expression *build_binary_ptr( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *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( maybeBuild<Expression>(expr_node1) ) );
         args.push_back( maybeBuild<Expression>(expr_node2) );
-        return new UntypedExpr( new NameExpr( opName[ op ] ), args );
+        return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 }
 
@@ -421 +365 @@
 }
 
-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 {
-        OperatorNode *op;
-        std::list<Expression *> args;
-
-        buildList( get_args(), args );
-
-        if ( ! ( op = dynamic_cast<OperatorNode *>( function ) ) ) { // function as opposed to operator
-                return new UntypedExpr( maybeBuild<Expression>(function), args, maybeBuild< Expression >( get_argName() ));
-        } // if
-
-        assert( ((void)"CompositeExprNode::build", false) );
-        return nullptr;
-}
-
-void CompositeExprNode::printOneLine( std::ostream &os, int indent ) const {
-        printDesignation( os );
-        os << "( ";
-        function->printOneLine( os, indent );
-        for ( ExpressionNode *cur = arguments; cur != 0; cur = dynamic_cast< ExpressionNode* >( cur->get_link() ) ) {
-                cur->printOneLine( os, indent );
-        } // for
-        os << ") ";
-}
-
-void CompositeExprNode::print( std::ostream &os, int indent ) const {
-        printDesignation( os );
-        os << string( indent, ' ' ) << "Application of: " << endl;
-        function->print( os, indent + ParseNode::indent_by );
-
-        os << string( indent, ' ' ) ;
-        if ( arguments ) {
-                os << "... on arguments: " << endl;
-                arguments->printList( os, indent + ParseNode::indent_by );
-        } else
-                os << "... on no arguments: " << endl;
-}
-
-void CompositeExprNode::set_function( ExpressionNode *f ) {
-        function = f;
-}
-
-void CompositeExprNode::set_args( ExpressionNode *args ) {
-        arguments = args;
-}
-
-ExpressionNode *CompositeExprNode::get_function( void ) const {
-        return function;
-}
-
-ExpressionNode *CompositeExprNode::get_args( void ) const {
-        return arguments;
-}
-
-void CompositeExprNode::add_arg( ExpressionNode *arg ) {
-        if ( arguments )
-                arguments->set_link( arg );
-        else
-                set_args( arg );
+Expression *build_range( ExpressionNode * low, ExpressionNode *high ) {
+        Expression *low_cexpr = maybeBuild<Expression>( low );
+        Expression *high_cexpr = maybeBuild<Expression>( high );
+        return new RangeExpr( low_cexpr, high_cexpr );
 }
 
@@ -676 +559 @@
 }
 
-ExpressionNode *flattenCommas( ExpressionNode *list ) {
-        if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) {
-                OperatorNode *op;
-                if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::Comma ) ) {
-                        if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
-                                composite->add_arg( next );
-                        return flattenCommas( composite->get_args() );
-                } // if
-        } // if
-
-        if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
-                list->set_next( flattenCommas( next ) );
-
-        return list;
-}
-
-ExpressionNode *tupleContents( ExpressionNode *tuple ) {
-        if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( tuple ) ) {
-                OperatorNode *op = 0;
-                if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::TupleC ) )
-                        return composite->get_args();
-        } // if
-        return tuple;
-}
-
 // Local Variables: //
 // tab-width: 4 //