Changeset d807ca28 for src/SynTree

Timestamp:

May 25, 2018, 5:01:37 PM (6 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:

3ed994e

Parents:

2c88368

git-author:

Rob Schluntz <rschlunt@…> (05/25/18 16:59:30)

git-committer:

Rob Schluntz <rschlunt@…> (05/25/18 17:01:37)

Message:

Add AST support for _Generic, along with C codegen

Location:

src/SynTree

Files:

• Expression.cc (modified) (1 diff)
• Expression.h (modified) (1 diff)
• Mutator.h (modified) (1 diff)
• SynTree.h (modified) (1 diff)
• Visitor.h (modified) (1 diff)

src/SynTree/Expression.cc

@@ -748 +748 @@
 }
 
+GenericExpr::Association::Association( Type * type, Expression * expr ) : type( type ), expr( expr ), isDefault( false ) {}
+GenericExpr::Association::Association( Expression * expr ) : type( nullptr ), expr( expr ), isDefault( true ) {}
+GenericExpr::Association::Association( const Association & other ) : type( maybeClone( other.type ) ), expr( maybeClone( other.expr ) ), isDefault( other.isDefault ) {}
+GenericExpr::Association::~Association() {
+        delete type;
+        delete expr;
+}
+
+GenericExpr::GenericExpr( Expression * control, const std::list<Association> & assoc ) : Expression(), control( control ), associations( assoc ) {}
+GenericExpr::GenericExpr( const GenericExpr & other ) : Expression(other), control( maybeClone( other.control ) ), associations( other.associations ) {
+}
+GenericExpr::~GenericExpr() {
+        delete control;
+}
+
+void GenericExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "C11 _Generic Expression" << std::endl << indent+1;
+        control->print( os, indent+1 );
+        os << std::endl << indent+1 << "... with associations: " << std::endl;
+        for ( const Association & assoc : associations ) {
+                os << indent+1;
+                if (assoc.isDefault) {
+                        os << "... default: ";
+                        assoc.expr->print( os, indent+1 );
+                } else {
+                        os << "... type: ";
+                        assoc.type->print( os, indent+1 );
+                        os << std::endl << indent+1 << "... expression: ";
+                        assoc.expr->print( os, indent+1 );
+                        os << std::endl;
+                }
+                os << std::endl;
+        }
+}
 
 // Local Variables: //

src/SynTree/Expression.h

@@ -865 +865 @@
 };
 
+/// C11 _Generic expression
+class GenericExpr : public Expression {
+public:
+        struct Association {
+                Type * type = nullptr;
+                Expression * expr = nullptr;
+                bool isDefault = false;
+
+                Association( Type * type, Expression * expr );
+                Association( Expression * expr );
+                Association( const Association & other );
+                Association & operator=( const Association & other ) = delete; // at the moment this isn't used, and I don't want to implement it
+                ~Association();
+        };
+
+        Expression * control;
+        std::list<Association> associations;
+
+        GenericExpr( Expression * control, const std::list<Association> & assoc );
+        GenericExpr( const GenericExpr & other );
+        virtual ~GenericExpr();
+
+        virtual GenericExpr * clone() const { return new GenericExpr( * this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+};
+
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Mutator.h

@@ -93 +93 @@
         virtual Expression * mutate( InitExpr  * initExpr ) = 0;
         virtual Expression * mutate( DeletedExpr * delExpr ) = 0;
+        virtual Expression * mutate( GenericExpr * genExpr ) = 0;
 
         virtual Type * mutate( VoidType * basicType ) = 0;

src/SynTree/SynTree.h

@@ -101 +101 @@
 class InitExpr;
 class DeletedExpr;
+class GenericExpr;
 
 class Type;

src/SynTree/Visitor.h

@@ -95 +95 @@
         virtual void visit( InitExpr *  initExpr ) = 0;
         virtual void visit( DeletedExpr * delExpr ) = 0;
+        virtual void visit( GenericExpr * genExpr ) = 0;
 
         virtual void visit( VoidType * basicType ) = 0;