Changes in src/Parser/ExpressionNode.cc [984dce6:630a82a]

File:

• src/Parser/ExpressionNode.cc (modified) (3 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 : Sun Mar 13 12:34:38 2016
-// Update Count     : 272
+// Last Modified On : Fri Apr  8 15:43:05 2016
+// Update Count     : 296
 // 
 
@@ -22 +22 @@
 
 #include "ParseNode.h"
+#include "TypeData.h"
 #include "SynTree/Constant.h"
 #include "SynTree/Expression.h"
+#include "SynTree/Declaration.h"
 #include "Common/UnimplementedError.h"
 #include "parseutility.h"
@@ -872 +874 @@
 }
 
+
+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 = type->build();                          // compound literal type
+        if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type
+                return new CompoundLiteralExpr( newDeclWithType->get_type(), kids->build() );
+        // 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() ), kids->build() );
+        } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl )  ) {
+                return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), kids->build() );
+        } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl )  ) {
+                return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), kids->build() );
+        } else {
+                assert( false );
+        } // if
+}
+
+
 ExpressionNode *flattenCommas( ExpressionNode *list ) {
         if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) {