Changes in src/Parser/ExpressionNode.cc [1869adf:e869d663]

File:

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

src/Parser/ExpressionNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Wed Jun 24 16:20:00 2015
-// Update Count     : 158
+// Last Modified On : Wed Aug 12 13:51:11 2015
+// Update Count     : 254
 // 
 
@@ -32 +32 @@
 ExpressionNode::ExpressionNode() : ParseNode(), argName( 0 ) {}
 
-ExpressionNode::ExpressionNode( const string *name_ ) : ParseNode( name_ ), argName( 0 ) {}
+ExpressionNode::ExpressionNode( const string *name ) : ParseNode( name ), argName( 0 ) {}
 
 ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.name ) {
@@ -42 +42 @@
 }
 
-ExpressionNode * ExpressionNode::set_asArgName( const std::string *aName ) {
+ExpressionNode * ExpressionNode::set_argName( const std::string *aName ) {
         argName = new VarRefNode( aName );
         return this;
 }
 
-ExpressionNode * ExpressionNode::set_asArgName( ExpressionNode *aDesignator ) {
+ExpressionNode * ExpressionNode::set_argName( ExpressionNode *aDesignator ) {
         argName = aDesignator;
         return this;
@@ -210 +210 @@
         assert( type == String );
 
-        // "abc" "def" "ghi" => "abcdefghi", so remove new text from quotes and insert before last quote in old string.
+        // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string.
         value.insert( value.length() - 1, newValue->substr( 1, newValue->length() - 2 ) );
         
@@ -284 +284 @@
         os << "Variable: " << get_name();
         os << endl;
+}
+
+//##############################################################################
+
+DesignatorNode::DesignatorNode( ExpressionNode *expr, bool isArrayIndex ) : isArrayIndex( isArrayIndex ) {
+        set_argName( expr );
+        assert( get_argName() );
+
+        if ( ! isArrayIndex ) {
+                if ( VarRefNode * var = dynamic_cast< VarRefNode * >( expr ) ) {
+
+                        stringstream ss( var->get_name() );
+                        double value;
+                        if ( ss >> value ) {
+                                // this is a floating point constant. It MUST be
+                                // ".0" or ".1", otherwise the program is invalid
+                                if ( ! (var->get_name() == ".0" || var->get_name() == ".1") ) {
+                                        throw SemanticError( "invalid designator name: " + var->get_name() );
+                                } // if
+                                var->set_name( var->get_name().substr(1) );
+                        } // if
+                } // if
+        } // if
+}
+
+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 {
+        Expression * ret = get_argName()->build();
+
+        if ( isArrayIndex ) {
+                // need to traverse entire structure and change any instances of 0 or 1 to 
+                // ConstantExpr
+                DesignatorFixer fixer;
+                ret = ret->acceptMutator( fixer );
+        } // if
+
+        return ret;
+}
+
+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
 }
 
@@ -330 +407 @@
 //##############################################################################
 
-CompositeExprNode::CompositeExprNode( void ) : ExpressionNode(), function( 0 ), arguments( 0 ) {
+CompositeExprNode::CompositeExprNode() : ExpressionNode(), function( 0 ), arguments( 0 ) {
 }
 
@@ -541 +618 @@
                 {
                         assert( args.size() == 3);
-                        std::list< Expression* >::const_iterator i = args.begin();
+                        std::list< Expression * >::const_iterator i = args.begin();
                         Expression *arg1 = notZeroExpr( *i++ );
                         Expression *arg2 = *i++;
@@ -552 +629 @@
                 {
                         assert( args.size() == 2);
-                        std::list< Expression* >::const_iterator i = args.begin();
+                        std::list< Expression * >::const_iterator i = args.begin();
                         Expression *ret = *i++;
                         while ( i != args.end() ) {
@@ -617 +694 @@
                 set_args( arg );
 }
+
+//##############################################################################
+
+Expression *AsmExprNode::build() const {
+        return new AsmExpr( maybeBuild< Expression >( inout ), (ConstantExpr *)constraint->build(), operand->build() );
+}
+
+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 << ") ";
+}
+
+//##############################################################################
+
+void LabelNode::print( std::ostream &os, int indent ) const {}
+
+void LabelNode::printOneLine( std::ostream &os, int indent ) const {}
 
 //##############################################################################