Changeset 7f6a7c9 for src/SynTree

Timestamp:

Sep 21, 2022, 11:02:15 AM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, master, pthread-emulation

Children:

95dab9e

Parents:

428adbc (diff), 0bd46fd (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 pthread-emulation

Location:

src/SynTree

Files:

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

src/SynTree/Declaration.h

@@ -145 +145 @@
         virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
 
-        // TODO: Move to the right place
         void checkAssignedValue() const;
 };
@@ -338 +337 @@
         typedef AggregateDecl Parent;
   public:
+        bool isTyped;
+        Type * base;
+
         EnumDecl( const std::string & name,
          const std::list< Attribute * > & attributes = std::list< class Attribute * >(),
-          LinkageSpec::Spec linkage = LinkageSpec::Cforall,
-          Type * baseType = nullptr ) : Parent( name, attributes, linkage ) , base( baseType ){}
-        EnumDecl( const EnumDecl & other ) : Parent( other ), base( other.base ) {}
-
+          bool isTyped = false, LinkageSpec::Spec linkage = LinkageSpec::Cforall,
+          Type * baseType = nullptr ) 
+          : Parent( name, attributes, linkage ),isTyped(isTyped), base( baseType ) {}
+        EnumDecl( const EnumDecl & other ) 
+          : Parent( other ), isTyped( other.isTyped), base( other.base ) {}
         bool valueOf( Declaration * enumerator, long long int & value );
-
         virtual EnumDecl * clone() const override { return new EnumDecl( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
-        Type * base;
-        std::unordered_map< std::string, long long int > enumValues;
+
+        std::unordered_map< std::string, long long int > enumValues; // This attribute is unused
         virtual void print( std::ostream & os, Indenter indent = {} ) const override final;
   private:

src/SynTree/Expression.h

@@ -163 +163 @@
 };
 
+// [Qualifier].name; Qualifier is the type_name from the parser
+class QualifiedNameExpr : public Expression {
+  public:
+        Declaration * type_decl;
+        std::string name;
+        DeclarationWithType * var;
+
+        QualifiedNameExpr( Declaration * decl, std::string name): Expression(), type_decl(decl), name(name) {}
+        QualifiedNameExpr( const QualifiedNameExpr & other): Expression(other), type_decl(other.type_decl), name(other.name), var(other.var) {}
+        DeclarationWithType * get_var() const { return var; }
+        void set_var( DeclarationWithType * newValue ) { var = newValue; }
+
+        virtual ~QualifiedNameExpr() {
+                delete var;
+                delete type_decl;
+        }
+
+        virtual QualifiedNameExpr * clone() const override {
+                return new QualifiedNameExpr( * this );
+        }
+        virtual void accept( Visitor & v ) override { v.visit(this); }
+        virtual void accept( Visitor & v ) const override { v.visit(this); }
+        virtual Expression * acceptMutator( Mutator & m ) override { 
+                return m.mutate( this ); 
+        }
+        
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override {
+                type_decl->print( os, indent );
+                os << name << std::endl;
+        }
+};
+
 /// VariableExpr represents an expression that simply refers to the value of a named variable.
 /// Does not take ownership of var.

src/SynTree/Mutator.h

@@ -98 +98 @@
         virtual Expression * mutate( DefaultArgExpr * argExpr ) = 0;
         virtual Expression * mutate( GenericExpr * genExpr ) = 0;
+        virtual Expression * mutate( QualifiedNameExpr * qualifiedNameExpr ) = 0;
 
         virtual Type * mutate( VoidType * basicType ) = 0;

src/SynTree/Statement.cc

@@ -105 +105 @@
 };
 
-BranchStmt::BranchStmt( Label target, Type type ) throw ( SemanticErrorException ) :
+BranchStmt::BranchStmt( Label target, Type type ) :
         Statement(), originalTarget( target ), target( target ), computedTarget( nullptr ), type( type ) {
         //actually this is a syntactic error signaled by the parser
@@ -113 +113 @@
 }
 
-BranchStmt::BranchStmt( Expression * computedTarget, Type type ) throw ( SemanticErrorException ) :
+BranchStmt::BranchStmt( Expression * computedTarget, Type type ) :
         Statement(), computedTarget( computedTarget ), type( type ) {
         if ( type != BranchStmt::Goto || computedTarget == nullptr ) {
@@ -211 +211 @@
 }
 
-CaseStmt::CaseStmt( Expression * condition, const list<Statement *> & statements, bool deflt ) throw ( SemanticErrorException ) :
+CaseStmt::CaseStmt( Expression * condition, const list<Statement *> & statements, bool deflt ) :
                 Statement(), condition( condition ), stmts( statements ), _isDefault( deflt ) {
         if ( isDefault() && condition != nullptr ) SemanticError( condition, "default case with condition: " );
@@ -575 +575 @@
 }
 
-MutexStmt::MutexStmt( Statement * stmt, const list<Expression *> mutexObjs ) 
+MutexStmt::MutexStmt( Statement * stmt, const list<Expression *> mutexObjs )
         : Statement(), stmt( stmt ), mutexObjs( mutexObjs ) { }
 

src/SynTree/Statement.h

@@ -200 +200 @@
         std::list<Statement *> stmts;
 
-        CaseStmt( Expression * conditions, const std::list<Statement *> & stmts, bool isdef = false ) throw (SemanticErrorException);
+        CaseStmt( Expression * conditions, const std::list<Statement *> & stmts, bool isdef = false );
         CaseStmt( const CaseStmt & other );
         virtual ~CaseStmt();
@@ -289 +289 @@
         Type type;
 
-        BranchStmt( Label target, Type ) throw (SemanticErrorException);
-        BranchStmt( Expression * computedTarget, Type ) throw (SemanticErrorException);
+        BranchStmt( Label target, Type );
+        BranchStmt( Expression * computedTarget, Type );
 
         Label get_originalTarget() { return originalTarget; }

src/SynTree/SynTree.h

@@ -103 +103 @@
 class DefaultArgExpr;
 class GenericExpr;
+class QualifiedNameExpr;
 
 class Type;

src/SynTree/Type.cc

@@ -80 +80 @@
 // These must remain in the same order as the corresponding bit fields.
 const char * Type::FuncSpecifiersNames[] = { "inline", "_Noreturn", "fortran" };
-const char * Type::StorageClassesNames[] = { "extern", "static", "auto", "register", "_Thread_local" };
+const char * Type::StorageClassesNames[] = { "extern", "static", "auto", "register", "__thread", "_Thread_local" };
 const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "mutex", "_Atomic" };
 

src/SynTree/Type.h

@@ -84 +84 @@
         }; // FuncSpecifiers
 
-        enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NumStorageClass = 5 };
+        enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, ThreadlocalGcc = 1 << 4, ThreadlocalC11 = 1 << 5, NumStorageClass = 6 };
         static const char * StorageClassesNames[];
         union StorageClasses {
@@ -93 +93 @@
                         bool is_auto : 1;
                         bool is_register : 1;
-                        bool is_threadlocal : 1;
+                        bool is_threadlocalGcc : 1;
+                        bool is_threadlocalC11 : 1;
                 };
 
@@ -100 +101 @@
                 // equality (==, !=) works implicitly on first field "val", relational operations are undefined.
                 BFCommon( StorageClasses, NumStorageClass )
+
+                bool is_threadlocal_any() { return this->is_threadlocalC11 || this->is_threadlocalGcc; }
         }; // StorageClasses
 
@@ -342 +345 @@
         Type * parent;
         Type * child;
-
         QualifiedType( const Type::Qualifiers & tq, Type * parent, Type * child );
         QualifiedType( const QualifiedType & tq );

src/SynTree/Visitor.h

@@ -101 +101 @@
         virtual void visit( NameExpr * node ) { visit( const_cast<const NameExpr *>(node) ); }
         virtual void visit( const NameExpr * nameExpr ) = 0;
+        virtual void visit( QualifiedNameExpr * node ) { visit( const_cast<const QualifiedNameExpr*>(node) );}
+        virtual void visit( const QualifiedNameExpr* qualifiednameExpr ) = 0;
         virtual void visit( CastExpr * node ) { visit( const_cast<const CastExpr *>(node) ); }
         virtual void visit( const CastExpr * castExpr ) = 0;