Changeset f6e3e34

Timestamp:

Apr 3, 2018, 11:13:10 AM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

92fea32

Parents:

3d2b7bc

Message:

Add StaticAssertDecl? node

Location:

src

Files:

• Common/PassVisitor.h (modified) (2 diffs)
• Common/PassVisitor.impl.h (modified) (3 diffs)
• Parser/DeclarationNode.cc (modified) (5 diffs)
• Parser/ParseNode.h (modified) (2 diffs)
• Parser/parser.yy (modified) (1 diff)
• SynTree/Declaration.cc (modified) (1 diff)
• SynTree/Declaration.h (modified) (1 diff)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/SynTree.h (modified) (1 diff)
• SynTree/Visitor.h (modified) (1 diff)

src/Common/PassVisitor.h

@@ -66 +66 @@
         virtual void visit( TypedefDecl * typeDecl ) override final;
         virtual void visit( AsmDecl * asmDecl ) override final;
+        virtual void visit( StaticAssertDecl * assertDecl ) override final;
 
         virtual void visit( CompoundStmt * compoundStmt ) override final;
@@ -161 +162 @@
         virtual Declaration * mutate( TypedefDecl * typeDecl ) override final;
         virtual AsmDecl * mutate( AsmDecl * asmDecl ) override final;
+        virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) override final;
 
         virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override final;

src/Common/PassVisitor.impl.h

@@ -685 +685 @@
 
 //--------------------------------------------------------------------------
+// StaticAssertDecl
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( StaticAssertDecl * node ) {
+        VISIT_START( node );
+
+        maybeAccept_impl( node->condition, *this );
+        maybeAccept_impl( node->message  , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+StaticAssertDecl * PassVisitor< pass_type >::mutate( StaticAssertDecl * node ) {
+        MUTATE_START( node );
+
+        maybeMutate_impl( node->condition, *this );
+        maybeMutate_impl( node->message  , *this );
+
+        MUTATE_END( StaticAssertDecl, node );
+}
+
+//--------------------------------------------------------------------------
 // CompoundStmt
 template< typename pass_type >
@@ -1490 +1512 @@
         indexerScopedAccept( node->result, *this );
         maybeAccept_impl   ( node->type  , *this );
-        maybeAccept_impl   ( node->member, *this );
 
         VISIT_END( node );
@@ -1502 +1523 @@
         indexerScopedMutate( node->result, *this );
         maybeMutate_impl   ( node->type  , *this );
-        maybeMutate_impl   ( node->member, *this );
 
         MUTATE_END( Expression, node );

src/Parser/DeclarationNode.cc

@@ -71 +71 @@
         attr.expr = nullptr;
         attr.type = nullptr;
+
+        assert.condition = nullptr;
+        assert.message = nullptr;
 }
 
@@ -88 +91 @@
         // asmName, no delete, passed to next stage
         delete initializer;
+
+        delete assert.condition;
+        delete assert.message;
 }
 
@@ -117 +123 @@
         newnode->attr.expr = maybeClone( attr.expr );
         newnode->attr.type = maybeClone( attr.type );
+
+        newnode->assert.condition = maybeClone( assert.condition );
+        newnode->assert.message = maybeClone( assert.message );
         return newnode;
 } // DeclarationNode::clone
@@ -434 +443 @@
         return newnode;
 }
+
+DeclarationNode * DeclarationNode::newStaticAssert( ExpressionNode * condition, Expression * message ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->assert.condition = condition;
+        newnode->assert.message = message;
+        return newnode;
+}
+
 
 void appendError( string & dst, const string & src ) {
@@ -1052 +1069 @@
         } // if
 
+        if ( assert.condition ) {
+                return new StaticAssertDecl( maybeBuild< Expression >( assert.condition ), strict_dynamic_cast< ConstantExpr * >( maybeClone( assert.message ) ) );
+        }
+
         // SUE's cannot have function specifiers, either
         //

src/Parser/ParseNode.h

@@ -246 +246 @@
         static DeclarationNode * newAttribute( std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
         static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
+        static DeclarationNode * newStaticAssert( ExpressionNode * condition, Expression * message );
 
         DeclarationNode();
@@ -313 +314 @@
         Attr_t attr;
 
+        struct StaticAssert_t {
+                ExpressionNode * condition;
+                Expression * message;
+        };
+        StaticAssert_t assert;
+
         BuiltinType builtin;
 

src/Parser/parser.yy

@@ -1308 +1308 @@
 static_assert:
         STATICASSERT '(' constant_expression ',' string_literal ')' ';' // C11
-                { SemanticError( yylloc, "Static assert is currently unimplemented." ); $$ = nullptr; } // FIX ME
+                { $$ = DeclarationNode::newStaticAssert( $3, $5 ); }
 
 // C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and function

src/SynTree/Declaration.cc

@@ -81 +81 @@
 
 
+StaticAssertDecl::StaticAssertDecl( Expression * condition, ConstantExpr * message ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), condition( condition ), message( message )  {
+}
+
+StaticAssertDecl::StaticAssertDecl( const StaticAssertDecl & other ) : Declaration( other ), condition( maybeClone( other.condition ) ), message( maybeClone( other.message ) )  {
+}
+
+StaticAssertDecl::~StaticAssertDecl() {
+        delete condition;
+        delete message;
+}
+
+void StaticAssertDecl::print( std::ostream &os, Indenter indent ) const {
+        os << "Static Assert with condition: ";
+        condition->print( os, indent+1 );
+        os << std::endl << indent << "and message: ";
+        message->print( os, indent+1 );
+os << std::endl;
+}
+
+void StaticAssertDecl::printShort( std::ostream &os, Indenter indent ) const {
+        print( os, indent );
+}
+
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Declaration.h

@@ -365 +365 @@
 };
 
+class StaticAssertDecl : public Declaration {
+public:
+        Expression * condition;
+        ConstantExpr * message;   // string literal
+
+        StaticAssertDecl( Expression * condition, ConstantExpr * message );
+        StaticAssertDecl( const StaticAssertDecl & other );
+        virtual ~StaticAssertDecl();
+
+        virtual StaticAssertDecl * clone() const override { return new StaticAssertDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual StaticAssertDecl * acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
+};
+
 std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data );
 

src/SynTree/Mutator.h

@@ -34 +34 @@
         virtual Declaration * mutate( TypedefDecl * typeDecl ) = 0;
         virtual AsmDecl * mutate( AsmDecl * asmDecl ) = 0;
+        virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) = 0;
 
         virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) = 0;

src/SynTree/SynTree.h

@@ -38 +38 @@
 class TypedefDecl;
 class AsmDecl;
+class StaticAssertDecl;
 
 class Statement;

src/SynTree/Visitor.h

@@ -36 +36 @@
         virtual void visit( TypedefDecl * typeDecl ) = 0;
         virtual void visit( AsmDecl * asmDecl ) = 0;
+        virtual void visit( StaticAssertDecl * assertDecl ) = 0;
 
         virtual void visit( CompoundStmt * compoundStmt ) = 0;