Changeset 28f3a19 for src/SynTree

Timestamp:

Jun 27, 2018, 3:28:41 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

new-env, with_gc

Children:

b21c77a

Parents:

0182bfa (diff), 63238a4 (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' into with_gc

Location:

src/SynTree

Files:

• BasicType.cc (modified) (1 diff)
• Declaration.cc (modified) (1 diff)
• Declaration.h (modified) (1 diff)
• Expression.cc (modified) (1 diff)
• Expression.h (modified) (1 diff)
• Mutator.h (modified) (1 diff)
• ReferenceToType.cc (modified) (5 diffs)
• Statement.cc (modified) (1 diff)
• Statement.h (modified) (1 diff)
• SynTree.h (modified) (1 diff)
• Type.cc (modified) (4 diffs)
• Type.h (modified) (1 diff)
• Visitor.h (modified) (1 diff)

src/SynTree/BasicType.cc

@@ -55 +55 @@
           case DoubleImaginary:
           case LongDoubleImaginary:
+          case Float80:
+          case Float128:
                 return false;
           case NUMBER_OF_BASIC_TYPES:

src/SynTree/Declaration.cc

@@ -92 +92 @@
 }
 
+
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Declaration.h

@@ -83 +83 @@
         Expression *asmName;
         std::list< Attribute * > attributes;
+        bool isDeleted = false;
 
         DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );

src/SynTree/Expression.cc

@@ -640 +640 @@
 
 
+DefaultArgExpr::DefaultArgExpr( Expression * expr ) : expr( expr ) {
+        assert( expr->result );
+        result = expr->result->clone();
+}
+DefaultArgExpr::DefaultArgExpr( const DefaultArgExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ) {}
+
+void DefaultArgExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "Default Argument Expression" << std::endl << indent+1;
+        expr->print( os, indent+1 );
+}
+
+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::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() {}
+
+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: //
 // tab-width: 4 //

src/SynTree/Expression.h

@@ -833 +833 @@
 };
 
+/// expression wrapping the use of a default argument - should never make it past the resolver.
+class DefaultArgExpr : public Expression {
+public:
+        Expression * expr;
+
+        DefaultArgExpr( Expression * expr );
+        DefaultArgExpr( const DefaultArgExpr & other );
+
+        virtual DefaultArgExpr * clone() const { return new DefaultArgExpr( * 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;
+};
+
+/// 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
+        };
+
+        Expression * control;
+        std::list<Association> associations;
+
+        GenericExpr( Expression * control, const std::list<Association> & assoc );
+        GenericExpr( const GenericExpr & other );
+        ~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( DefaultArgExpr * argExpr ) = 0;
+        virtual Expression * mutate( GenericExpr * genExpr ) = 0;
 
         virtual Type * mutate( VoidType * basicType ) = 0;

src/SynTree/ReferenceToType.cc

@@ -46 +46 @@
 
 namespace {
-        void doLookup( const std::list< Declaration* > &members, const std::string &name, std::list< Declaration* > &foundDecls ) {
-                for ( std::list< Declaration* >::const_iterator i = members.begin(); i != members.end(); ++i ) {
-                        if ( (*i)->get_name() == name ) {
-                                foundDecls.push_back( *i );
+        void doLookup( const std::list< Declaration * > & members, const std::string & name, std::list< Declaration* > & foundDecls ) {
+                for ( Declaration * decl : members ) {
+                        if ( decl->name == name ) {
+                                foundDecls.push_back( decl );
                         } // if
                 } // for
@@ -56 +56 @@
 
 StructInstType::StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes ) :
-                Parent( tq, baseStruct->get_name(), attributes ), baseStruct( baseStruct ) {}
+                Parent( tq, baseStruct->name, attributes ), baseStruct( baseStruct ) {}
 
 std::string StructInstType::typeString() const { return "struct"; }
@@ -80 +80 @@
 void StructInstType::lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const {
         assert( baseStruct );
-        doLookup( baseStruct->get_members(), name, foundDecls );
+        doLookup( baseStruct->members, name, foundDecls );
 }
 
@@ -99 +99 @@
 
 UnionInstType::UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes ) :
-                Parent( tq, baseUnion->get_name(), attributes ), baseUnion( baseUnion ) {}
+                Parent( tq, baseUnion->name, attributes ), baseUnion( baseUnion ) {}
 
 std::string UnionInstType::typeString() const { return "union"; }
@@ -123 +123 @@
 void UnionInstType::lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const {
         assert( baseUnion );
-        doLookup( baseUnion->get_members(), name, foundDecls );
+        doLookup( baseUnion->members, name, foundDecls );
 }
 

src/SynTree/Statement.cc

@@ -208 +208 @@
 }
 
-WhileStmt::WhileStmt( Expression *condition, Statement *body, bool isDoWhile ):
-        Statement(), condition( condition), body( body), isDoWhile( isDoWhile) {
+WhileStmt::WhileStmt( Expression *condition, Statement *body, std::list< Statement * > & initialization, bool isDoWhile ):
+        Statement(), condition( condition), body( body), initialization( initialization ), isDoWhile( isDoWhile) {
 }
 

src/SynTree/Statement.h

@@ -213 +213 @@
         Expression *condition;
         Statement *body;
+        std::list<Statement *> initialization;
         bool isDoWhile;
 
         WhileStmt( Expression *condition,
-               Statement *body, bool isDoWhile = false );
+               Statement *body, std::list<Statement *> & initialization, bool isDoWhile = false );
         WhileStmt( const WhileStmt &other );
 

src/SynTree/SynTree.h

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

src/SynTree/Type.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 25 15:16:32 2017
-// Update Count     : 38
+// Last Modified On : Fri Jun 22 10:17:19 2018
+// Update Count     : 39
 //
 #include "Type.h"
@@ -24 +24 @@
 using namespace std;
 
-const char *BasicType::typeNames[BasicType::NUMBER_OF_BASIC_TYPES] = {
+const char *BasicType::typeNames[] = {
         "_Bool",
         "char",
@@ -48 +48 @@
         "__int128",
         "unsigned __int128",
+        "__float80",
+        "__float128"
 };
+static_assert(
+        sizeof(BasicType::typeNames)/sizeof(BasicType::typeNames[0]) == BasicType::NUMBER_OF_BASIC_TYPES,
+        "Each basic type name should have a corresponding kind enum value"
+);
 
 Type::Type( const Qualifiers &tq, const std::list< Attribute * > & attributes ) : tq( tq ), attributes( attributes ) {}
@@ -58 +64 @@
 
 // These must remain in the same order as the corresponding bit fields.
-const char * Type::FuncSpecifiersNames[] = { "inline", "fortran", "_Noreturn" };
+const char * Type::FuncSpecifiersNames[] = { "inline", "_Noreturn", "fortran" };
 const char * Type::StorageClassesNames[] = { "extern", "static", "auto", "register", "_Thread_local" };
 const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic" };

src/SynTree/Type.h

@@ -230 +230 @@
                 SignedInt128,
                 UnsignedInt128,
+                Float80,
+                Float128,
                 NUMBER_OF_BASIC_TYPES
         } kind;

src/SynTree/Visitor.h

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