Changeset b0d9ff7 for src/SynTree

Timestamp:

Sep 1, 2022, 1:27:52 PM (20 months ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

12df6fe

Parents:

def751f

Message:

Fix up the QualifiedNameExpr?. It should now work on both old AST and new AST. There are some known bugs to fix so make all-tests will fail.

Location:

src/SynTree

Files:

• Declaration.h (modified) (2 diffs)
• Expression.h (modified) (2 diffs)
• Mutator.h (modified) (1 diff)
• Type.h (modified) (1 diff)
• 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

@@ -166 +166 @@
 class QualifiedNameExpr : public Expression {
   public:
-        Type * type; // Convert to [parent] QualifiedNameExpr
-        std::string name; // Convert from NameExpr
-
-        QualifiedNameExpr( Type * type, std::string name): 
-                Expression(), type(type), name(name) {
-                std::cout << "Making QualifiedNameExpr" << std::endl;
-                print( std::cout );
-        }
-        QualifiedNameExpr( const QualifiedNameExpr & other): Expression(other), type(other.type), name(other.name) {
-
-        }
+        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 type;
+                delete var;
+                delete type_decl;
         }
 
@@ -184 +183 @@
                 return new QualifiedNameExpr( * this );
         }
-        virtual void accept( Visitor & v ) override { (void)v; }
-        virtual void accept( Visitor & v ) const override { (void)v; }
-        virtual Expression * acceptMutator( Mutator & m ) override { (void) m;return nullptr; }
+        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->print( os, indent );
-                std::cout << name << std::endl;
+                type_decl->print( os, indent );
+                os << name << std::endl;
         }
 };

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/Type.h

@@ -342 +342 @@
         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;