Changeset 65cdc1e

Timestamp:

Aug 9, 2017, 3:21:58 PM (8 years ago)

Author:

Andrew Beach <ajbeach@…>

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, resolv-new, with_gc

Children:

0ec9229

Parents:

cbce272

Message:

Syntax Nodes give public access to the fields with effective public access.X

Location:

src

Files:

• Parser/ExpressionNode.cc (modified) (2 diffs)
• SynTree/Declaration.cc (modified) (2 diffs)
• SynTree/Declaration.h (modified) (15 diffs)
• SynTree/Expression.h (modified) (65 diffs)
• SynTree/Initializer.h (modified) (9 diffs)
• SynTree/Statement.h (modified) (26 diffs)
• SynTree/Type.cc (modified) (2 diffs)
• SynTree/Type.h (modified) (22 diffs)
• SynTree/TypeDecl.cc (modified) (2 diffs)

src/Parser/ExpressionNode.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:17:07 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jul 27 21:42:38 2017
-// Update Count     : 567
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  2 11:12:00 2017
+// Update Count     : 568
 //
 
@@ -40 +40 @@
 // type.
 
-Type::Qualifiers noQualifiers;                          // no qualifiers on constants
+extern const Type::Qualifiers noQualifiers;             // no qualifiers on constants
 
 static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }

src/SynTree/Declaration.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 16 07:49:18 2017
-// Update Count     : 24
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  9 14:38:00 2017
+// Update Count     : 25
 //
 
@@ -28 +28 @@
 
 Declaration::Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage )
-                : name( name ), storageClasses( scs ), linkage( linkage ), uniqueId( 0 ) {
+                : name( name ), linkage( linkage ), storageClasses( scs ), uniqueId( 0 ) {
 }
 
 Declaration::Declaration( const Declaration &other )
-        : BaseSyntaxNode( other ), name( other.name ), storageClasses( other.storageClasses ), linkage( other.linkage ), uniqueId( other.uniqueId ) {
+        : BaseSyntaxNode( other ), name( other.name ), linkage( other.linkage ), extension( other.extension ), storageClasses( other.storageClasses ), uniqueId( other.uniqueId ) {
 }
 

src/SynTree/Declaration.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Tus Aug  8 13:25:00 2017
-// Update Count     : 125
+// Last Modified On : Wed Aug  9 14:45:00 2017
+// Update Count     : 126
 //
 
@@ -27 +27 @@
 class Declaration : public BaseSyntaxNode {
   public:
+        std::string name;
+        LinkageSpec::Spec linkage;
+        bool extension = false;
+
         Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage );
         Declaration( const Declaration &other );
@@ -53 +57 @@
         static void dumpIds( std::ostream &os );
         static Declaration *declFromId( UniqueId id );
-  private:
-        std::string name;
+
+  private:
         Type::StorageClasses storageClasses;
-        LinkageSpec::Spec linkage;
         UniqueId uniqueId;
-        bool extension = false;
 };
 
 class DeclarationWithType : public Declaration {
   public:
-        DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
-        DeclarationWithType( const DeclarationWithType &other );
-        virtual ~DeclarationWithType();
-
-        std::string get_mangleName() const { return mangleName; }
-        DeclarationWithType * set_mangleName( std::string newValue ) { mangleName = newValue; return this; }
-
-        std::string get_scopedMangleName() const { return mangleName + "_" + std::to_string(scopeLevel); }
-
-        int get_scopeLevel() const { return scopeLevel; }
-        DeclarationWithType * set_scopeLevel( int newValue ) { scopeLevel = newValue; return this; }
-
-        ConstantExpr *get_asmName() const { return asmName; }
-        DeclarationWithType * set_asmName( ConstantExpr *newValue ) { asmName = newValue; return this; }
-
-        std::list< Attribute * >& get_attributes() { return attributes; }
-        const std::list< Attribute * >& get_attributes() const { return attributes; }
-
-        Type::FuncSpecifiers get_funcSpec() const { return fs; }
-        //void set_functionSpecifiers( Type::FuncSpecifiers newValue ) { fs = newValue; }
-
-        virtual DeclarationWithType *clone() const = 0;
-        virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
-
-        virtual Type *get_type() const = 0;
-        virtual void set_type(Type *) = 0;
-  private:
         // this represents the type with all types and typedefs expanded it is generated by SymTab::Validate::Pass2
         std::string mangleName;
@@ -97 +72 @@
         ConstantExpr *asmName;
         std::list< Attribute * > attributes;
+
+        DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
+        DeclarationWithType( const DeclarationWithType &other );
+        virtual ~DeclarationWithType();
+
+        std::string get_mangleName() const { return mangleName; }
+        DeclarationWithType * set_mangleName( std::string newValue ) { mangleName = newValue; return this; }
+
+        std::string get_scopedMangleName() const { return mangleName + "_" + std::to_string(scopeLevel); }
+
+        int get_scopeLevel() const { return scopeLevel; }
+        DeclarationWithType * set_scopeLevel( int newValue ) { scopeLevel = newValue; return this; }
+
+        ConstantExpr *get_asmName() const { return asmName; }
+        DeclarationWithType * set_asmName( ConstantExpr *newValue ) { asmName = newValue; return this; }
+
+        std::list< Attribute * >& get_attributes() { return attributes; }
+        const std::list< Attribute * >& get_attributes() const { return attributes; }
+
+        Type::FuncSpecifiers get_funcSpec() const { return fs; }
+        //void set_functionSpecifiers( Type::FuncSpecifiers newValue ) { fs = newValue; }
+
+        virtual DeclarationWithType *clone() const = 0;
+        virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
+
+        virtual Type *get_type() const = 0;
+        virtual void set_type(Type *) = 0;
+
+  private:
         Type::FuncSpecifiers fs;
 };
@@ -103 +107 @@
         typedef DeclarationWithType Parent;
   public:
+        Type *type;
+        Initializer *init;
+        Expression *bitfieldWidth;
+
         ObjectDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init,
                                 const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
@@ -122 +130 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
-  private:
-        Type *type;
-        Initializer *init;
-        Expression *bitfieldWidth;
 };
 
@@ -131 +135 @@
         typedef DeclarationWithType Parent;
   public:
+        FunctionType *type;
+        CompoundStmt *statements;
+
         FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements,
                                   const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
@@ -149 +156 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
-  private:
-        FunctionType *type;
-        CompoundStmt *statements;
 };
 
@@ -157 +161 @@
         typedef Declaration Parent;
   public:
+        Type *base;
+        std::list< TypeDecl* > parameters;
+        std::list< DeclarationWithType* > assertions;
+
         NamedTypeDecl( const std::string &name, Type::StorageClasses scs, Type *type );
         NamedTypeDecl( const NamedTypeDecl &other );
@@ -171 +179 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
-  protected:
-  private:
-        Type *base;
-        std::list< TypeDecl* > parameters;
-        std::list< DeclarationWithType* > assertions;
 };
 
@@ -182 +185 @@
   public:
         enum Kind { Any, Dtype, Ftype, Ttype };
+
+        Type * init;
+        bool sized;
+
         /// Data extracted from a type decl
         struct Data {
@@ -216 +223 @@
   private:
         Kind kind;
-        Type * init;
-        bool sized;
 };
 
@@ -237 +242 @@
         typedef Declaration Parent;
   public:
-        AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
-        AggregateDecl( const AggregateDecl &other );
-        virtual ~AggregateDecl();
-
-        std::list<Declaration*>& get_members() { return members; }
-        std::list<TypeDecl*>& get_parameters() { return parameters; }
-
-        std::list< Attribute * >& get_attributes() { return attributes; }
-        const std::list< Attribute * >& get_attributes() const { return attributes; }
-
-        bool has_body() const { return body; }
-        AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
-
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-        virtual void printShort( std::ostream &os, int indent = 0 ) const;
-  protected:
-        virtual std::string typeString() const = 0;
-
-  private:
         std::list<Declaration*> members;
         std::list<TypeDecl*> parameters;
         bool body;
         std::list< Attribute * > attributes;
+
+        AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
+        AggregateDecl( const AggregateDecl &other );
+        virtual ~AggregateDecl();
+
+        std::list<Declaration*>& get_members() { return members; }
+        std::list<TypeDecl*>& get_parameters() { return parameters; }
+
+        std::list< Attribute * >& get_attributes() { return attributes; }
+        const std::list< Attribute * >& get_attributes() const { return attributes; }
+
+        bool has_body() const { return body; }
+        AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
+
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const;
+  protected:
+        virtual std::string typeString() const = 0;
 };
 
@@ -333 +337 @@
 class AsmDecl : public Declaration {
   public:
+        AsmStmt *stmt;
+
         AsmDecl( AsmStmt *stmt );
         AsmDecl( const AsmDecl &other );
@@ -345 +351 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
-  private:
-        AsmStmt *stmt;
 };
 

src/SynTree/Expression.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Mon Jul 24 16:27:00 2017
-// Update Count     : 43
+// Last Modified On : Fri Aug  8 11:54:00 2017
+// Update Count     : 44
 //
 
@@ -29 +29 @@
 class Expression : public BaseSyntaxNode{
   public:
+        Type * result;
+        TypeSubstitution * env;
+        Expression * argName; // if expression is used as an argument, it can be "designated" by this name
+        bool extension = false;
+
         Expression( Expression * _aname = nullptr );
         Expression( const Expression & other );
@@ -49 +54 @@
         virtual Expression * acceptMutator( Mutator & m ) = 0;
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  protected:
-        Type * result;
-        TypeSubstitution * env;
-        Expression * argName; // if expression is used as an argument, it can be "designated" by this name
-        bool extension = false;
 };
 
@@ -79 +79 @@
 class ApplicationExpr : public Expression {
   public:
+        Expression * function;
+
         ApplicationExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >() );
         ApplicationExpr( const ApplicationExpr & other );
@@ -92 +94 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+
   private:
-        Expression * function;
         std::list<Expression *> args;
         InferredParams inferParams;
@@ -103 +105 @@
 class UntypedExpr : public Expression {
   public:
+        Expression * function;
+        std::list<Expression*> args;
+
         UntypedExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >(), Expression *_aname = nullptr );
         UntypedExpr( const UntypedExpr & other );
@@ -123 +128 @@
         virtual void print( std::ostream & os, int indent = 0 ) const;
         virtual void printArgs(std::ostream & os, int indent = 0) const;
-  private:
-        Expression * function;
-        std::list<Expression*> args;
 };
 
@@ -131 +133 @@
 class NameExpr : public Expression {
   public:
+        std::string name;
+
         NameExpr( std::string name, Expression *_aname = nullptr );
         NameExpr( const NameExpr & other );
@@ -142 +146 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        std::string name;
 };
 
@@ -152 +154 @@
 class AddressExpr : public Expression {
   public:
+        Expression * arg;
+
         AddressExpr( Expression * arg, Expression *_aname = nullptr );
         AddressExpr( const AddressExpr & other );
@@ -163 +167 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * arg;
 };
 
@@ -170 +172 @@
 class LabelAddressExpr : public Expression {
   public:
+        Expression * arg;
+
         LabelAddressExpr( Expression * arg );
         LabelAddressExpr( const LabelAddressExpr & other );
@@ -181 +185 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * arg;
 };
 
@@ -188 +190 @@
 class CastExpr : public Expression {
   public:
+        Expression * arg;
+
         CastExpr( Expression * arg, Expression *_aname = nullptr );
         CastExpr( Expression * arg, Type * toType, Expression *_aname = nullptr );
@@ -200 +204 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * arg;
 };
 
@@ -207 +209 @@
 class VirtualCastExpr : public Expression {
   public:
+        Expression * arg;
+
         VirtualCastExpr( Expression * arg, Type * toType );
         VirtualCastExpr( const VirtualCastExpr & other );
@@ -218 +222 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * arg;
 };
 
@@ -225 +227 @@
 class UntypedMemberExpr : public Expression {
   public:
+        Expression * member;
+        Expression * aggregate;
+
         UntypedMemberExpr( Expression * member, Expression * aggregate, Expression *_aname = nullptr );
         UntypedMemberExpr( const UntypedMemberExpr & other );
@@ -238 +243 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * member;
-        Expression * aggregate;
 };
 
@@ -247 +249 @@
 class MemberExpr : public Expression {
   public:
+        DeclarationWithType * member;
+        Expression * aggregate;
+
         MemberExpr( DeclarationWithType * member, Expression * aggregate, Expression *_aname = nullptr );
         MemberExpr( const MemberExpr & other );
@@ -260 +265 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        DeclarationWithType * member;
-        Expression * aggregate;
 };
 
@@ -269 +271 @@
 class VariableExpr : public Expression {
   public:
+        DeclarationWithType * var;
+
         VariableExpr( DeclarationWithType * var, Expression *_aname = nullptr );
         VariableExpr( const VariableExpr & other );
@@ -280 +284 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        DeclarationWithType * var;
 };
 
@@ -287 +289 @@
 class ConstantExpr : public Expression {
   public:
+        Constant constant;
+
         ConstantExpr( Constant constant, Expression *_aname = nullptr );
         ConstantExpr( const ConstantExpr & other );
@@ -298 +302 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Constant constant;
 };
 
@@ -305 +307 @@
 class SizeofExpr : public Expression {
   public:
+        Expression * expr;
+        Type * type;
+        bool isType;
+
         SizeofExpr( Expression * expr, Expression *_aname = nullptr );
         SizeofExpr( const SizeofExpr & other );
@@ -321 +327 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
+};
+
+/// AlignofExpr represents an alignof expression
+class AlignofExpr : public Expression {
+  public:
         Expression * expr;
         Type * type;
         bool isType;
-};
-
-/// AlignofExpr represents an alignof expression
-class AlignofExpr : public Expression {
-  public:
+
         AlignofExpr( Expression * expr, Expression *_aname = nullptr );
         AlignofExpr( const AlignofExpr & other );
@@ -346 +352 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * expr;
-        Type * type;
-        bool isType;
 };
 
@@ -355 +357 @@
 class UntypedOffsetofExpr : public Expression {
   public:
+        Type * type;
+        std::string member;
+
         UntypedOffsetofExpr( Type * type, const std::string & member, Expression *_aname = nullptr );
         UntypedOffsetofExpr( const UntypedOffsetofExpr & other );
@@ -368 +373 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Type * type;
-        std::string member;
 };
 
@@ -376 +378 @@
 class OffsetofExpr : public Expression {
   public:
+        Type * type;
+        DeclarationWithType * member;
+
         OffsetofExpr( Type * type, DeclarationWithType * member, Expression *_aname = nullptr );
         OffsetofExpr( const OffsetofExpr & other );
@@ -389 +394 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Type * type;
-        DeclarationWithType * member;
 };
 
@@ -397 +399 @@
 class OffsetPackExpr : public Expression {
 public:
+        StructInstType * type;
+
         OffsetPackExpr( StructInstType * type_, Expression * aname_ = 0 );
         OffsetPackExpr( const OffsetPackExpr & other );
@@ -407 +411 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-
-        virtual void print( std::ostream & os, int indent = 0 ) const;
-
-private:
-        StructInstType * type;
+        virtual void print( std::ostream & os, int indent = 0 ) const;
 };
 
@@ -417 +417 @@
 class AttrExpr : public Expression {
   public:
+        Expression * attr;
+        Expression * expr;
+        Type * type;
+        bool isType;
+
         AttrExpr(Expression * attr, Expression * expr, Expression *_aname = nullptr );
         AttrExpr( const AttrExpr & other );
@@ -435 +440 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * attr;
-        Expression * expr;
-        Type * type;
-        bool isType;
 };
 
@@ -445 +445 @@
 class LogicalExpr : public Expression {
   public:
+        Expression * arg1;
+        Expression * arg2;
+
         LogicalExpr( Expression * arg1, Expression * arg2, bool andp = true, Expression *_aname = nullptr );
         LogicalExpr( const LogicalExpr & other );
@@ -459 +462 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+
   private:
+        bool isAnd;
+};
+
+/// ConditionalExpr represents the three-argument conditional ( p ? a : b )
+class ConditionalExpr : public Expression {
+  public:
         Expression * arg1;
         Expression * arg2;
-        bool isAnd;
-};
-
-/// ConditionalExpr represents the three-argument conditional ( p ? a : b )
-class ConditionalExpr : public Expression {
-  public:
+        Expression * arg3;
+
         ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3, Expression *_aname = nullptr );
         ConditionalExpr( const ConditionalExpr & other );
@@ -483 +489 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
+};
+
+/// CommaExpr represents the sequence operator ( a, b )
+class CommaExpr : public Expression {
+  public:
         Expression * arg1;
         Expression * arg2;
-        Expression * arg3;
-};
-
-/// CommaExpr represents the sequence operator ( a, b )
-class CommaExpr : public Expression {
-  public:
+
         CommaExpr( Expression * arg1, Expression * arg2, Expression *_aname = nullptr );
         CommaExpr( const CommaExpr & other );
@@ -505 +510 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * arg1;
-        Expression * arg2;
 };
 
@@ -513 +515 @@
 class TypeExpr : public Expression {
   public:
+        Type * type;
+
         TypeExpr( Type * type );
         TypeExpr( const TypeExpr & other );
@@ -524 +528 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Type * type;
 };
 
@@ -531 +533 @@
 class AsmExpr : public Expression {
   public:
+        Expression * inout;
+        ConstantExpr * constraint;
+        Expression * operand;
+
         AsmExpr( Expression * inout, ConstantExpr * constraint, Expression * operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
         AsmExpr( const AsmExpr & other );
@@ -548 +554 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
+
         // https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
-        Expression * inout;
-        ConstantExpr * constraint;
-        Expression * operand;
 };
 
@@ -559 +562 @@
 class ImplicitCopyCtorExpr : public Expression {
 public:
-        ImplicitCopyCtorExpr( ApplicationExpr * callExpr );
-        ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other );
-        virtual ~ImplicitCopyCtorExpr();
-
-        ApplicationExpr * get_callExpr() const { return callExpr; }
-        void set_callExpr( ApplicationExpr * newValue ) { callExpr = newValue; }
-
-        std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
-        std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
-        std::list< Expression * > & get_dtors() { return dtors; }
-
-        virtual ImplicitCopyCtorExpr * clone() const { return new ImplicitCopyCtorExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
         ApplicationExpr * callExpr;
         std::list< ObjectDecl * > tempDecls;
         std::list< ObjectDecl * > returnDecls;
         std::list< Expression * > dtors;
+
+        ImplicitCopyCtorExpr( ApplicationExpr * callExpr );
+        ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other );
+        virtual ~ImplicitCopyCtorExpr();
+
+        ApplicationExpr * get_callExpr() const { return callExpr; }
+        void set_callExpr( ApplicationExpr * newValue ) { callExpr = newValue; }
+
+        std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
+        std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
+        std::list< Expression * > & get_dtors() { return dtors; }
+
+        virtual ImplicitCopyCtorExpr * clone() const { return new ImplicitCopyCtorExpr( * this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
 };
 
@@ -584 +587 @@
 class ConstructorExpr : public Expression {
 public:
+        Expression * callExpr;
+
         ConstructorExpr( Expression * callExpr );
         ConstructorExpr( const ConstructorExpr & other );
@@ -595 +600 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-private:
-        Expression * callExpr;
 };
 
@@ -602 +605 @@
 class CompoundLiteralExpr : public Expression {
   public:
+        Initializer * initializer;
+
         CompoundLiteralExpr( Type * type, Initializer * initializer );
         CompoundLiteralExpr( const CompoundLiteralExpr & other );
@@ -613 +618 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Initializer * initializer;
 };
 
@@ -620 +623 @@
 class RangeExpr : public Expression {
   public:
+        Expression * low, * high;
+
         RangeExpr( Expression * low, Expression * high );
         RangeExpr( const RangeExpr & other );
@@ -632 +637 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * low, * high;
 };
 
@@ -639 +642 @@
 class UntypedTupleExpr : public Expression {
   public:
+        std::list<Expression*> exprs;
+
         UntypedTupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
         UntypedTupleExpr( const UntypedTupleExpr & other );
@@ -649 +654 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        std::list<Expression*> exprs;
 };
 
@@ -656 +659 @@
 class TupleExpr : public Expression {
   public:
+        std::list<Expression*> exprs;
+
         TupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
         TupleExpr( const TupleExpr & other );
@@ -666 +671 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        std::list<Expression*> exprs;
 };
 
@@ -673 +676 @@
 class TupleIndexExpr : public Expression {
   public:
+        Expression * tuple;
+        unsigned int index;
+
         TupleIndexExpr( Expression * tuple, unsigned int index );
         TupleIndexExpr( const TupleIndexExpr & other );
@@ -686 +692 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * tuple;
-        unsigned int index;
 };
 
@@ -694 +697 @@
 class TupleAssignExpr : public Expression {
   public:
+        StmtExpr * stmtExpr = nullptr;
+
         TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname = nullptr );
         TupleAssignExpr( const TupleAssignExpr & other );
@@ -705 +710 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        StmtExpr * stmtExpr = nullptr;
 };
 
@@ -712 +715 @@
 class StmtExpr : public Expression {
 public:
+        CompoundStmt * statements;
+        std::list< ObjectDecl * > returnDecls; // return variable(s) for stmt expression
+        std::list< Expression * > dtors; // destructor(s) for return variable(s)
+
         StmtExpr( CompoundStmt * statements );
         StmtExpr( const StmtExpr & other );
@@ -726 +733 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-private:
-        CompoundStmt * statements;
-        std::list< ObjectDecl * > returnDecls; // return variable(s) for stmt expression
-        std::list< Expression * > dtors; // destructor(s) for return variable(s)
 };
 
 class UniqueExpr : public Expression {
 public:
+        Expression * expr;
+        ObjectDecl * object;
+        VariableExpr * var;
+
         UniqueExpr( Expression * expr, long long idVal = -1 );
         UniqueExpr( const UniqueExpr & other );
@@ -753 +760 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+
 private:
-        Expression * expr;
-        ObjectDecl * object;
-        VariableExpr * var;
         int id;
         static long long count;
@@ -773 +778 @@
 class UntypedInitExpr : public Expression {
 public:
+        Expression * expr;
+        std::list<InitAlternative> initAlts;
+
         UntypedInitExpr( Expression * expr, const std::list<InitAlternative> & initAlts );
         UntypedInitExpr( const UntypedInitExpr & other );
@@ -786 +794 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-private:
-        Expression * expr;
-        std::list<InitAlternative> initAlts;
 };
 
 class InitExpr : public Expression {
 public:
+        Expression * expr;
+        Designation * designation;
+
         InitExpr( Expression * expr, Designation * designation );
         InitExpr( const InitExpr & other );
@@ -807 +815 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-private:
-        Expression * expr;
-        Designation * designation;
 };
 

src/SynTree/Initializer.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:52:02 2017
-// Update Count     : 21
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  9 10:19:00 2017
+// Update Count     : 22
 //
 
@@ -27 +27 @@
 class Designation : public BaseSyntaxNode {
 public:
+        std::list< Expression * > designators;
+
         Designation( const std::list< Expression * > & designators );
         Designation( const Designation & other );
@@ -37 +39 @@
         virtual Designation * acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-private:
-        std::list< Expression * > designators;
 };
 
@@ -63 +63 @@
 class SingleInit : public Initializer {
   public:
+        //Constant *value;
+        Expression *value;      // has to be a compile-time constant
+
         SingleInit( Expression *value, bool maybeConstructed = false );
         SingleInit( const SingleInit &other );
@@ -74 +77 @@
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        //Constant *value;
-        Expression *value;      // has to be a compile-time constant
 };
 
@@ -83 +83 @@
 class ListInit : public Initializer {
   public:
+        std::list<Initializer *> initializers;  // order *is* important
+        std::list<Designation *> designations;  // order/length is consistent with initializers
+
         ListInit( const std::list<Initializer*> &initializers,
                           const std::list<Designation *> &designators = {}, bool maybeConstructed = false );
@@ -102 +105 @@
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        std::list<Initializer *> initializers;  // order *is* important
-        std::list<Designation *> designations;  // order/length is consistent with initializers
 };
 
@@ -113 +113 @@
 class ConstructorInit : public Initializer {
   public:
+        Statement * ctor;
+        Statement * dtor;
+
         ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init );
         ConstructorInit( const ConstructorInit &other );
@@ -130 +133 @@
 
   private:
-        Statement * ctor;
-        Statement * dtor;
         // C-style initializer made up of SingleInit and ListInit nodes to use as a fallback
         // if an appropriate constructor definition is not found by the resolver

src/SynTree/Statement.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:54:32 2017
-// Update Count     : 68
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Aug  3 14:08:00 2017
+// Update Count     : 69
 //
 
@@ -26 +26 @@
 class Statement : public BaseSyntaxNode {
   public:
+        std::list<Label> labels;
+
         Statement( std::list<Label> labels );
         virtual ~Statement();
@@ -36 +38 @@
         virtual Statement *acceptMutator( Mutator &m ) = 0;
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  protected:
-        std::list<Label> labels;
 };
 
 class CompoundStmt : public Statement {
   public:
+        std::list<Statement*> kids;
+
         CompoundStmt( std::list<Label> labels );
         CompoundStmt( const CompoundStmt &other );
@@ -54 +56 @@
         virtual CompoundStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        std::list<Statement*> kids;
 };
 
@@ -67 +67 @@
         virtual NullStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-
-  private:
 };
 
 class ExprStmt : public Statement {
   public:
+        Expression *expr;
+
         ExprStmt( std::list<Label> labels, Expression *expr );
         ExprStmt( const ExprStmt &other );
@@ -84 +84 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        Expression *expr;
 };
 
 class AsmStmt : public Statement {
   public:
+        bool voltile;
+        ConstantExpr *instruction;
+        std::list<Expression *> output, input;
+        std::list<ConstantExpr *> clobber;
+        std::list<Label> gotolabels;
+
         AsmStmt( std::list<Label> labels, bool voltile, ConstantExpr *instruction, std::list<Expression *> input, std::list<Expression *> output, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
         AsmStmt( const AsmStmt &other );
@@ -111 +115 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        bool voltile;
-        ConstantExpr *instruction;
-        std::list<Expression *> output, input;
-        std::list<ConstantExpr *> clobber;
-        std::list<Label> gotolabels;
 };
 
 class IfStmt : public Statement {
   public:
+        Expression *condition;
+        Statement *thenPart;
+        Statement *elsePart;
+
         IfStmt( std::list<Label> labels, Expression *condition, Statement *thenPart, Statement *elsePart );
         IfStmt( const IfStmt &other );
@@ -136 +138 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        Expression *condition;
-        Statement *thenPart;
-        Statement *elsePart;
 };
 
 class SwitchStmt : public Statement {
   public:
+        Expression * condition;
+
         SwitchStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &statements );
         SwitchStmt( const SwitchStmt &other );
@@ -159 +159 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
+        std::list<Statement *> statements;
+};
+
+class CaseStmt : public Statement {
+  public:
         Expression * condition;
-        std::list<Statement *> statements;
-};
-
-class CaseStmt : public Statement {
-  public:
+        std::list<Statement *> stmts;
+
         CaseStmt( std::list<Label> labels, Expression *conditions, std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
         CaseStmt( const CaseStmt &other );
@@ -186 +188 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
-        Expression * condition;
-        std::list<Statement *> stmts;
         bool _isDefault;
 };
@@ -193 +193 @@
 class WhileStmt : public Statement {
   public:
+        Expression *condition;
+        Statement *body;
+        bool isDoWhile;
+
         WhileStmt( std::list<Label> labels, Expression *condition,
                Statement *body, bool isDoWhile = false );
@@ -209 +213 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
+};
+
+class ForStmt : public Statement {
+  public:
+        std::list<Statement *> initialization;
         Expression *condition;
+        Expression *increment;
         Statement *body;
-        bool isDoWhile;
-};
-
-class ForStmt : public Statement {
-  public:
+
         ForStmt( std::list<Label> labels, std::list<Statement *> initialization,
              Expression *condition = 0, Expression *increment = 0, Statement *body = 0 );
@@ -235 +240 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        std::list<Statement *> initialization;
-        Expression *condition;
-        Expression *increment;
-        Statement *body;
 };
 
@@ -245 +245 @@
   public:
         enum Type { Goto = 0, Break, Continue };
+
+        // originalTarget kept for error messages.
+        const Label originalTarget;
+        Label target;
+        Expression *computedTarget;
+        Type type;
 
         BranchStmt( std::list<Label> labels, Label target, Type ) throw (SemanticError);
@@ -265 +271 @@
   private:
         static const char *brType[];
-        Label originalTarget;  // can give better error messages if we remember the label name that the user entered
-        Label target;
-        Expression *computedTarget;
-        Type type;
 };
 
 class ReturnStmt : public Statement {
   public:
+        Expression *expr;
+
         ReturnStmt( std::list<Label> labels, Expression *expr );
         ReturnStmt( const ReturnStmt &other );
@@ -284 +288 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        Expression *expr;
 };
 
@@ -291 +293 @@
   public:
         enum Kind { Terminate, Resume };
+
+        const Kind kind;
+        Expression * expr;
+        Expression * target;
 
         ThrowStmt( std::list<Label> labels, Kind kind, Expression * expr, Expression * target = nullptr );
@@ -306 +312 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        Kind kind;
-        Expression * expr;
-        Expression * target;
 };
 
 class TryStmt : public Statement {
   public:
+        CompoundStmt *block;
+        std::list<CatchStmt *> handlers;
+        FinallyStmt *finallyBlock;
+
         TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 );
         TryStmt( const TryStmt &other );
@@ -329 +335 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-
-  private:
-        CompoundStmt *block;
-        std::list<CatchStmt *> handlers;
-        FinallyStmt *finallyBlock;
 };
 
@@ -339 +340 @@
   public:
         enum Kind { Terminate, Resume };
+
+        const Kind kind;
+        Declaration *decl;
+        Expression *cond;
+        Statement *body;
 
         CatchStmt( std::list<Label> labels, Kind kind, Declaration *decl,
@@ -357 +363 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-
-  private:
-        Kind kind;
-        Declaration *decl;
-        Expression *cond;
-        Statement *body;
 };
 
 class FinallyStmt : public Statement {
   public:
+        CompoundStmt *block;
+
         FinallyStmt( std::list<Label> labels, CompoundStmt *block );
         FinallyStmt( const FinallyStmt &other );
@@ -378 +380 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        CompoundStmt *block;
 };
 
@@ -386 +386 @@
 class DeclStmt : public Statement {
   public:
+        Declaration *decl;
+
         DeclStmt( std::list<Label> labels, Declaration *decl );
         DeclStmt( const DeclStmt &other );
@@ -397 +399 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        Declaration *decl;
 };
 
@@ -407 +407 @@
 class ImplicitCtorDtorStmt : public Statement {
   public:
+        // Non-owned pointer to the constructor/destructor statement
+        Statement * callStmt;
+
         ImplicitCtorDtorStmt( Statement * callStmt );
         ImplicitCtorDtorStmt( const ImplicitCtorDtorStmt & other );
@@ -418 +421 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-
-  private:
-        // Non-owned pointer to the constructor/destructor statement
-        Statement * callStmt;
 };
 

src/SynTree/Type.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 17 08:42:47 2017
-// Update Count     : 28
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  2 11:11:00 2017
+// Update Count     : 29
 //
 
@@ -88 +88 @@
 }
 
+// Empty Variable declarations:
+const Type::FuncSpecifiers noFuncSpecifiers;
+const Type::StorageClasses noStorageClasses;
+const Type::Qualifiers noQualifiers;
+
 std::ostream & operator<<( std::ostream & out, const Type * type ) {
         if ( type ) {

src/SynTree/Type.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:53:29 2017
-// Update Count     : 151
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  9 14:25:00 2017
+// Update Count     : 152
 //
 
@@ -127 +127 @@
         }; // Qualifiers
 
+        typedef std::list<TypeDecl *> ForallList;
+
+        Qualifiers tq;
+        ForallList forall;
+        std::list< Attribute * > attributes;
+
         Type( const Qualifiers & tq, const std::list< Attribute * > & attributes );
         Type( const Type & other );
@@ -145 +151 @@
         void set_atomic( bool newValue ) { tq.is_atomic = newValue; }
 
-        typedef std::list<TypeDecl *> ForallList;
         ForallList& get_forall() { return forall; }
 
@@ -165 +170 @@
         virtual Type *acceptMutator( Mutator & m ) = 0;
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Qualifiers tq;
-        ForallList forall;
-        std::list< Attribute * > attributes;
-};
-
-extern Type::Qualifiers noQualifiers;                           // no qualifiers on constants
+};
+
+extern const Type::FuncSpecifiers noFuncSpecifiers;
+extern const Type::StorageClasses noStorageClasses;
+extern const Type::Qualifiers noQualifiers;                     // no qualifiers on constants
 
 class VoidType : public Type {
@@ -211 +214 @@
                 LongDoubleImaginary,
                 NUMBER_OF_BASIC_TYPES
-        };
+        } kind;
 
         static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
@@ -226 +229 @@
 
         bool isInteger() const;
-  private:
-        Kind kind;
 };
 
 class PointerType : public Type {
   public:
+        Type *base;
+
+        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
+        Expression *dimension;
+        bool isVarLen;
+        bool isStatic;
+
         PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
@@ -252 +260 @@
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
+};
+
+class ArrayType : public Type {
+  public:
         Type *base;
-
-        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
         Expression *dimension;
         bool isVarLen;
         bool isStatic;
-};
-
-class ArrayType : public Type {
-  public:
+
         ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         ArrayType( const ArrayType& );
@@ -282 +288 @@
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Type *base;
-        Expression *dimension;
-        bool isVarLen;
-        bool isStatic;
 };
 
 class FunctionType : public Type {
   public:
+        std::list<DeclarationWithType*> returnVals;
+        std::list<DeclarationWithType*> parameters;
+
+        // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
+        // This could be because of
+        // - an ellipsis in a prototype declaration
+        // - an unprototyped declaration
+        bool isVarArgs;
+
         FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         FunctionType( const FunctionType& );
@@ -305 +315 @@
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        std::list<DeclarationWithType*> returnVals;
-        std::list<DeclarationWithType*> parameters;
-
-        // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
-        // This could be because of
-        // - an ellipsis in a prototype declaration
-        // - an unprototyped declaration
-        bool isVarArgs;
 };
 
 class ReferenceToType : public Type {
   public:
+        std::list< Expression* > parameters;
+        std::string name;
+        bool hoistType;
+
         ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
         ReferenceToType( const ReferenceToType & other );
@@ -336 +341 @@
   protected:
         virtual std::string typeString() const = 0;
-        std::list< Expression* > parameters;
-        std::string name;
-  private:
-        bool hoistType;
 };
 
@@ -345 +346 @@
         typedef ReferenceToType Parent;
   public:
+        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
+        // where the structure used in this type is actually defined
+        StructDecl *baseStruct;
+
         StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
         StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
@@ -368 +373 @@
   private:
         virtual std::string typeString() const;
-
-        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
-        // where the structure used in this type is actually defined
-        StructDecl *baseStruct;
 };
 
@@ -377 +378 @@
         typedef ReferenceToType Parent;
   public:
+        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
+        // where the union used in this type is actually defined
+        UnionDecl *baseUnion;
+
         UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
         UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
@@ -400 +405 @@
   private:
         virtual std::string typeString() const;
-
+};
+
+class EnumInstType : public ReferenceToType {
+        typedef ReferenceToType Parent;
+  public:
         // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
         // where the union used in this type is actually defined
-        UnionDecl *baseUnion;
-};
-
-class EnumInstType : public ReferenceToType {
-        typedef ReferenceToType Parent;
-  public:
+        EnumDecl *baseEnum = nullptr;
+
         EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
         EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
@@ -423 +428 @@
   private:
         virtual std::string typeString() const;
-
-        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
-        // where the union used in this type is actually defined
-        EnumDecl *baseEnum = nullptr;
 };
 
@@ -432 +433 @@
         typedef ReferenceToType Parent;
   public:
+        // this member is filled in by the validate pass, which instantiates the members of the correponding
+        // aggregate with the actual type parameters specified for this use of the context
+        std::list< Declaration* > members;
+
         TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
         TraitInstType( const TraitInstType & other );
@@ -445 +450 @@
   private:
         virtual std::string typeString() const;
-
-        // this member is filled in by the validate pass, which instantiates the members of the correponding
-        // aggregate with the actual type parameters specified for this use of the context
-        std::list< Declaration* > members;
 };
 
@@ -454 +455 @@
         typedef ReferenceToType Parent;
   public:
+        // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
+        // where the type used here is actually defined
+        TypeDecl *baseType;
+        bool isFtype;
+
         TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
@@ -472 +478 @@
   private:
         virtual std::string typeString() const;
-        // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
-        // where the type used here is actually defined
-        TypeDecl *baseType;
-        bool isFtype;
 };
 
 class TupleType : public Type {
   public:
+        std::list<Type *> types;
+        std::list<Declaration *> members;
+
         TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TupleType( const TupleType& );
@@ -508 +513 @@
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        std::list<Type *> types;
-        std::list<Declaration *> members;
 };
 
 class TypeofType : public Type {
   public:
+        Expression *expr;
+
         TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TypeofType( const TypeofType& );
@@ -528 +532 @@
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
+};
+
+class AttrType : public Type {
+  public:
+        std::string name;
         Expression *expr;
-};
-
-class AttrType : public Type {
-  public:
+        Type *type;
+        bool isType;
+
         AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
@@ -554 +561 @@
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        std::string name;
-        Expression *expr;
-        Type *type;
-        bool isType;
 };
 

src/SynTree/TypeDecl.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 16 07:49:58 2017
-// Update Count     : 5
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  9 14:35:00 2017
+// Update Count     : 6
 //
 
@@ -18 +18 @@
 #include "Common/utility.h"
 
-TypeDecl::TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, Type * init ) : Parent( name, scs, type ), kind( kind ), init( init ), sized( kind == Any || kind == Ttype ) {
+TypeDecl::TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, Type * init ) : Parent( name, scs, type ), init( init ), sized( kind == Any || kind == Ttype ), kind( kind ) {
 }
 
-TypeDecl::TypeDecl( const TypeDecl &other ) : Parent( other ), kind( other.kind ), init( maybeClone( other.init ) ), sized( other.sized ) {
+TypeDecl::TypeDecl( const TypeDecl &other ) : Parent( other ), init( maybeClone( other.init ) ), sized( other.sized ), kind( other.kind ) {
 }