Changeset 630a82a for src/Parser

Timestamp:

Apr 8, 2016, 5:22:29 PM (10 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, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc

Children:

3da470c

Parents:

3d9b5da

Message:

C99 compound literals now work, comment rational code, clean up hoisting AddVisit

Location:

src/Parser

Files:

• ExpressionNode.cc (modified) (3 diffs)
• ParseNode.h (modified) (2 diffs)
• parser.yy (modified) (2 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 ) ) {

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  2 17:26:35 2016
-// Update Count     : 190
+// Last Modified On : Fri Apr  8 16:27:20 2016
+// Update Count     : 205
 //
 
@@ -538 +538 @@
 };
 
+class CompoundLiteralNode : public ExpressionNode {
+  public:
+        CompoundLiteralNode( DeclarationNode *type, InitializerNode *kids );
+        CompoundLiteralNode( const CompoundLiteralNode &type );
+        ~CompoundLiteralNode();
+
+        virtual CompoundLiteralNode *clone() const;
+
+        DeclarationNode *get_type() const { return type; }
+        CompoundLiteralNode *set_type( DeclarationNode *t ) { type = t; return this; }
+
+        InitializerNode *get_initializer() const { return kids; }
+        CompoundLiteralNode *set_initializer( InitializerNode *k ) { kids = k; return this; }
+
+        void print( std::ostream &, int indent = 0 ) const;
+        void printOneLine( std::ostream &, int indent = 0 ) const;
+
+        virtual Expression *build() const;
+  private:
+        DeclarationNode *type;
+        InitializerNode *kids;
+};
+
 template< typename SynTreeType, typename NodeType >
 void buildList( const NodeType *firstNode, std::list< SynTreeType *> &outputList ) {

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 24 16:16:16 2016
-// Update Count     : 1498
+// Last Modified On : Fri Apr  8 16:21:55 2016
+// Update Count     : 1508
 // 
 
@@ -372 +372 @@
                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::DecrPost ), $1 ); }
         | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99
-                { $$ = 0; }
+                { $$ = new CompoundLiteralNode( $2, new InitializerNode( $5, true ) ); }
         | postfix_expression '{' argument_expression_list '}' // CFA
                 {