Changeset 94b1022a for src/Parser

Timestamp:

May 30, 2018, 9:28:18 PM (6 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, with_gc

Children:

bd946e4

Parents:

35718a9 (diff), ae32d96 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg2:software/cfa/cfa-cc

Location:

src/Parser

Files:

• DeclarationNode.cc (modified) (1 diff)
• InitializerNode.cc (modified) (4 diffs)
• ParseNode.h (modified) (3 diffs)
• TypeData.cc (modified) (3 diffs)
• parser.yy (modified) (4 diffs)

src/Parser/DeclarationNode.cc

@@ -1067 +1067 @@
                         SemanticError( this, "invalid function specifier for " );
                 } // if
-                return buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
+                bool isDelete = initializer && initializer->get_isDelete();
+                Declaration * decl = buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, isDelete ? nullptr : maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
+                if ( isDelete ) {
+                        DeclarationWithType * dwt = strict_dynamic_cast<DeclarationWithType *>( decl );
+                        dwt->isDeleted = true;
+                }
+                return decl;
         } // if
 

src/Parser/InitializerNode.cc

@@ -27 +27 @@
 
 InitializerNode::InitializerNode( ExpressionNode * _expr, bool aggrp, ExpressionNode * des )
-                : expr( _expr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ) {
+                : expr( _expr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ), isDelete( false ) {
         if ( aggrp )
                 kids = dynamic_cast< InitializerNode * >( get_next() );
@@ -36 +36 @@
 
 InitializerNode::InitializerNode( InitializerNode * init, bool aggrp, ExpressionNode * des )
-                : expr( nullptr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ) {
+                : expr( nullptr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ), isDelete( false ) {
         if ( init )
                 set_last( init );
@@ -46 +46 @@
                 set_next( nullptr );
 } // InitializerNode::InitializerNode
+
+InitializerNode::InitializerNode( bool isDelete ) : expr( nullptr ), aggregate( false ), designator( nullptr ), kids( nullptr ), maybeConstructed( false ), isDelete( isDelete ) {}
 
 InitializerNode::~InitializerNode() {
@@ -84 +86 @@
 
 Initializer * InitializerNode::build() const {
+        assertf( ! isDelete, "Should not build delete stmt InitializerNode" );
         if ( aggregate ) {
                 // steal designators from children

src/Parser/ParseNode.h

@@ -87 +87 @@
         InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = nullptr );
         InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
+        InitializerNode( bool isDelete );
         ~InitializerNode();
         virtual InitializerNode * clone() const { assert( false ); return nullptr; }
@@ -97 +98 @@
         InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
         bool get_maybeConstructed() const { return maybeConstructed; }
+
+        bool get_isDelete() const { return isDelete; }
 
         InitializerNode * next_init() const { return kids; }
@@ -110 +113 @@
         InitializerNode * kids;
         bool maybeConstructed;
+        bool isDelete;
 }; // InitializerNode
 

src/Parser/TypeData.cc

@@ -65 +65 @@
           case Aggregate:
                 // aggregate = new Aggregate_t;
+                aggregate.kind = DeclarationNode::NoAggregate;
                 aggregate.name = nullptr;
                 aggregate.params = nullptr;
@@ -70 +71 @@
                 aggregate.fields = nullptr;
                 aggregate.body = false;
+                aggregate.tagged = false;
+                aggregate.parent = nullptr;
                 break;
           case AggregateInst:
@@ -198 +201 @@
                 break;
           case Aggregate:
+                newtype->aggregate.kind = aggregate.kind;
                 newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr;
                 newtype->aggregate.params = maybeClone( aggregate.params );
                 newtype->aggregate.actuals = maybeClone( aggregate.actuals );
                 newtype->aggregate.fields = maybeClone( aggregate.fields );
-                newtype->aggregate.kind = aggregate.kind;
                 newtype->aggregate.body = aggregate.body;
                 newtype->aggregate.tagged = aggregate.tagged;

src/Parser/parser.yy

@@ -175 +175 @@
         bool flag;
         CatchStmt::Kind catch_kind;
+        GenericExpr * genexpr;
 }
 
@@ -259 +260 @@
 %type<flag> asm_volatile_opt
 %type<en> handler_predicate_opt
+%type<genexpr> generic_association generic_assoc_list
 
 // statements
@@ -501 +503 @@
                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
         | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11
-                { SemanticError( yylloc, "_Generic is currently unimplemented." ); $$ = nullptr; }
+                {
+                        // add the missing control expression to the GenericExpr and return it
+                        $5->control = maybeMoveBuild<Expression>( $3 );
+                        $$ = new ExpressionNode( $5 );
+                }
         ;
 
 generic_assoc_list:                                                                             // C11
-        | generic_association
+        generic_association
         | generic_assoc_list ',' generic_association
+                {
+                        // steal the association node from the singleton and delete the wrapper
+                        $1->associations.splice($1->associations.end(), $3->associations);
+                        delete $3;
+                        $$ = $1;
+                }
         ;
 
 generic_association:                                                                    // C11
         type_no_function ':' assignment_expression
+                {
+                        // create a GenericExpr wrapper with one association pair
+                        $$ = new GenericExpr( nullptr, { { maybeMoveBuildType($1), maybeMoveBuild<Expression>($3) } } );
+                }
         | DEFAULT ':' assignment_expression
+                { $$ = new GenericExpr( nullptr, { { maybeMoveBuild<Expression>($3) } } ); }
         ;
 
@@ -2081 +2098 @@
                 { $$ = $2; }
         | '=' VOID
-                { $$ = nullptr; }
+                { $$ = new InitializerNode( true ); }
         | ATassign initializer
                 { $$ = $2->set_maybeConstructed( false ); }