Changeset 1cdfa82 for src/SynTree

Timestamp:

Apr 25, 2018, 4:55:53 PM (7 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

new-env, with_gc

Children:

42107b4

Parents:

2efe4b8 (diff), 9d5fb67 (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 remote-tracking branch 'origin/master' into with_gc

Location:

src/SynTree

Files:

• CompoundStmt.cc (modified) (3 diffs)
• DeclReplacer.cc (added)
• DeclReplacer.h (moved) (moved from src/SynTree/VarExprReplacer.h ) (1 diff)
• Declaration.cc (modified) (1 diff)
• Declaration.h (modified) (1 diff)
• Expression.cc (modified) (2 diffs)
• Expression.h (modified) (2 diffs)
• FunctionDecl.cc (modified) (3 diffs)
• Mutator.h (modified) (2 diffs)
• Statement.cc (modified) (4 diffs)
• Statement.h (modified) (2 diffs)
• SynTree.h (modified) (2 diffs)
• TypeSubstitution.cc (modified) (1 diff)
• TypeSubstitution.h (modified) (1 diff)
• VarExprReplacer.cc (deleted)
• Visitor.h (modified) (2 diffs)
• module.mk (modified) (1 diff)

src/SynTree/CompoundStmt.cc

@@ -23 +23 @@
 #include "Statement.h"                // for CompoundStmt, Statement, DeclStmt
 #include "SynTree/Label.h"            // for Label
-#include "SynTree/VarExprReplacer.h"  // for VarExprReplacer, VarExprReplace...
+#include "SynTree/DeclReplacer.h"     // for DeclReplacer
 
 using std::string;
@@ -49 +49 @@
         // recursively execute this routine. There may be more efficient ways of doing
         // this.
-        VarExprReplacer::DeclMap declMap;
+        DeclReplacer::DeclMap declMap;
         std::list< Statement * >::const_iterator origit = other.kids.begin();
         for ( Statement * s : kids ) {
@@ -64 +64 @@
         }
         if ( ! declMap.empty() ) {
-                VarExprReplacer::replace( this, declMap );
+                DeclReplacer::replace( this, declMap );
         }
 }

src/SynTree/DeclReplacer.h

@@ -23 +23 @@
 class VariableExpr;
 
-namespace VarExprReplacer {
+namespace DeclReplacer {
         typedef std::map< DeclarationWithType *, DeclarationWithType * > DeclMap;
+        typedef std::map< TypeDecl *, TypeDecl * > TypeMap;
 
         void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false );
+        void replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug = false );
+        void replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
 }
 

src/SynTree/Declaration.cc

@@ -74 +74 @@
 
 
+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

@@ -357 +357 @@
 };
 
+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/Expression.cc

@@ -238 +238 @@
 }
 
-CastExpr::CastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
+CastExpr::CastExpr( Expression *arg, Type *toType, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
         set_result(toType);
 }
 
-CastExpr::CastExpr( Expression *arg_ ) : Expression(), arg(arg_) {
+CastExpr::CastExpr( Expression *arg, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
         set_result( new VoidType( Type::Qualifiers() ) );
 }
 
-CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
+CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
 }
 
@@ -259 +259 @@
                 result->print( os, indent+1 );
         } // if
+        Expression::print( os, indent );
+}
+
+KeywordCastExpr::KeywordCastExpr( Expression *arg, Target target ) : Expression(), arg(arg), target( target ) {
+}
+
+KeywordCastExpr::KeywordCastExpr( const KeywordCastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), target( other.target ) {
+}
+
+KeywordCastExpr::~KeywordCastExpr() {
+        delete arg;
+}
+
+const std::string & KeywordCastExpr::targetString() const {
+        static const std::string targetStrs[] = {
+                "coroutine", "thread", "monitor"
+        };
+        static_assert(
+                (sizeof(targetStrs) / sizeof(targetStrs[0])) == ((unsigned long)NUMBER_OF_TARGETS),
+                "Each KeywordCastExpr::Target should have a corresponding string representation"
+        );
+        return targetStrs[(unsigned long)target];
+}
+
+void KeywordCastExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Keyword Cast of:" << std::endl << indent+1;
+        arg->print(os, indent+1);
+        os << std::endl << indent << "... to: ";
+        os << targetString();
         Expression::print( os, indent );
 }

src/SynTree/Expression.h

@@ -184 +184 @@
   public:
         Expression * arg;
-
-        CastExpr( Expression * arg );
-        CastExpr( Expression * arg, Type * toType );
+        bool isGenerated = true; // whether this cast appeared in the source program
+
+        CastExpr( Expression * arg, bool isGenerated = true );
+        CastExpr( Expression * arg, Type * toType, bool isGenerated = true );
+        CastExpr( Expression * arg, void * ) = delete; // prevent accidentally passing pointers for isGenerated in the first constructor
         CastExpr( const CastExpr & other );
 
@@ -193 +195 @@
 
         virtual CastExpr * clone() const { return new CastExpr( * 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;
+};
+
+/// KeywordCastExpr represents a cast to 'keyword types', e.g. (thread &)t
+class KeywordCastExpr : public Expression {
+public:
+        Expression * arg;
+        enum Target {
+                Coroutine, Thread, Monitor, NUMBER_OF_TARGETS
+        } target;
+
+        KeywordCastExpr( Expression * arg, Target target );
+        KeywordCastExpr( const KeywordCastExpr & other );
+        virtual ~KeywordCastExpr();
+
+        const std::string & targetString() const;
+
+        virtual KeywordCastExpr * clone() const { return new KeywordCastExpr( * this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }

src/SynTree/FunctionDecl.cc

@@ -26 +26 @@
 #include "Statement.h"           // for CompoundStmt
 #include "Type.h"                // for Type, FunctionType, Type::FuncSpecif...
-#include "VarExprReplacer.h"
+#include "DeclReplacer.h"
 
 extern bool translation_unit_nomain;
@@ -41 +41 @@
                 : Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ) {
 
-        VarExprReplacer::DeclMap declMap;
+        DeclReplacer::DeclMap declMap;
         for ( auto p : group_iterate( other.type->parameters, type->parameters ) ) {
                 declMap[ std::get<0>(p) ] = std::get<1>(p);
@@ -49 +49 @@
         }
         if ( ! declMap.empty() ) {
-                VarExprReplacer::replace( this, declMap );
+                DeclReplacer::replace( this, declMap );
         }
         cloneAll( other.withExprs, withExprs );

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;
@@ -58 +59 @@
         virtual Expression * mutate( UntypedExpr * untypedExpr ) = 0;
         virtual Expression * mutate( NameExpr * nameExpr ) = 0;
-        virtual Expression * mutate( AddressExpr * castExpr ) = 0;
+        virtual Expression * mutate( AddressExpr * addrExpr ) = 0;
         virtual Expression * mutate( LabelAddressExpr * labAddressExpr ) = 0;
         virtual Expression * mutate( CastExpr * castExpr ) = 0;
+        virtual Expression * mutate( KeywordCastExpr * castExpr ) = 0;
         virtual Expression * mutate( VirtualCastExpr * castExpr ) = 0;
         virtual Expression * mutate( UntypedMemberExpr * memberExpr ) = 0;

src/SynTree/Statement.cc

@@ -34 +34 @@
 Statement::Statement( const std::list<Label> & labels ) : labels( labels ) {}
 
-void Statement::print( std::ostream & os, Indenter ) const {
+void Statement::print( std::ostream & os, Indenter indent ) const {
         if ( ! labels.empty() ) {
-                os << "Labels: {";
+                os << indent << "... Labels: {";
                 for ( const Label & l : labels ) {
                         os << l << ",";
@@ -188 +188 @@
 
 void CaseStmt::print( std::ostream &os, Indenter indent ) const {
-        if ( isDefault() ) os << "Default ";
+        if ( isDefault() ) os << indent << "Default ";
         else {
-                os << "Case ";
+                os << indent << "Case ";
                 condition->print( os, indent );
         } // if
@@ -196 +196 @@
 
         for ( Statement * stmt : stmts ) {
+                os << indent+1;
                 stmt->print( os, indent+1 );
         }
@@ -391 +392 @@
 }
 
-void NullStmt::print( std::ostream &os, Indenter ) const {
+void NullStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Null Statement" << endl;
+        Statement::print( os, indent );
 }
 

src/SynTree/Statement.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Sep  3 20:46:46 2017
-// Update Count     : 77
+// Last Modified On : Thu Mar  8 14:53:02 2018
+// Update Count     : 78
 //
 
@@ -246 +246 @@
 class BranchStmt : public Statement {
   public:
-        enum Type { Goto = 0, Break, Continue };
+        enum Type { Goto = 0, Break, Continue, FallThrough, FallThroughDefault };
 
         // originalTarget kept for error messages.

src/SynTree/SynTree.h

@@ -38 +38 @@
 class TypedefDecl;
 class AsmDecl;
+class StaticAssertDecl;
 
 class Statement;
@@ -68 +69 @@
 class LabelAddressExpr;
 class CastExpr;
+class KeywordCastExpr;
 class VirtualCastExpr;
 class MemberExpr;

src/SynTree/TypeSubstitution.cc

@@ -132 +132 @@
                 return inst;
         } else {
-///         std::cerr << "found " << inst->get_name() << ", replacing with ";
-///         i->second->print( std::cerr );
-///         std::cerr << std::endl;
+                // cut off infinite loop for the case where a type is bound to itself.
+                // Note: this does not prevent cycles in the general case, so it may be necessary to do something more sophisticated here.
+                // TODO: investigate preventing type variables from being bound to themselves in the first place.
+                if ( TypeInstType * replacement = dynamic_cast< TypeInstType * >( i->second ) ) {
+                        if ( inst->name == replacement->name ) {
+                                return inst;
+                        }
+                }
+                // std::cerr << "found " << inst->name << ", replacing with " << i->second << std::endl;
                 subCount++;
                 Type * newtype = i->second->clone();
                 newtype->get_qualifiers() |= inst->get_qualifiers();
-                return newtype;
+                // Note: need to recursively apply substitution to the new type because normalize does not substitute bound vars, but bound vars must be substituted when not in freeOnly mode.
+                return newtype->acceptMutator( *visitor );
         } // if
 }

src/SynTree/TypeSubstitution.h

@@ -125 +125 @@
 
 // definitition must happen after PassVisitor is included so that WithGuards can be used
-struct TypeSubstitution::Substituter : public WithGuards {
+struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter> {
                 Substituter( TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
 

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;
@@ -61 +62 @@
         virtual void visit( NameExpr * nameExpr ) = 0;
         virtual void visit( CastExpr * castExpr ) = 0;
+        virtual void visit( KeywordCastExpr * castExpr ) = 0;
         virtual void visit( VirtualCastExpr * castExpr ) = 0;
         virtual void visit( AddressExpr * addressExpr ) = 0;

src/SynTree/module.mk

@@ -49 +49 @@
        SynTree/Attribute.cc \
        SynTree/BaseSyntaxNode.cc \
-       SynTree/VarExprReplacer.cc
+       SynTree/DeclReplacer.cc