Index: src/SynTree/AggregateDecl.cc =================================================================== --- src/SynTree/AggregateDecl.cc (revision cfaa2873f31b6edf27dbf9fb7a544ce6a7bb2a93) +++ src/SynTree/AggregateDecl.cc (revision bffcd663a600d87ff5b237df6c2c43c0d99f2c02) @@ -10,6 +10,6 @@ // Created On : Sun May 17 23:56:39 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Dec 11 16:31:55 2019 -// Update Count : 29 +// Last Modified On : Fri Dec 13 23:10:22 2019 +// Update Count : 30 // @@ -22,5 +22,5 @@ #include "Declaration.h" // for AggregateDecl, TypeDecl, Declaration #include "Initializer.h" -#include "Parser/LinkageSpec.h" // for Spec, linkageName, Cforall +#include "LinkageSpec.h" // for Spec, linkageName, Cforall #include "Type.h" // for Type, Type::StorageClasses Index: src/SynTree/Declaration.h =================================================================== --- src/SynTree/Declaration.h (revision cfaa2873f31b6edf27dbf9fb7a544ce6a7bb2a93) +++ src/SynTree/Declaration.h (revision bffcd663a600d87ff5b237df6c2c43c0d99f2c02) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Dec 11 16:48:20 2019 -// Update Count : 149 +// Last Modified On : Fri Dec 13 23:11:22 2019 +// Update Count : 157 // @@ -24,5 +24,5 @@ #include "BaseSyntaxNode.h" // for BaseSyntaxNode #include "Mutator.h" // for Mutator -#include "Parser/LinkageSpec.h" // for Spec, Cforall +#include "LinkageSpec.h" // for Spec, Cforall #include "SynTree.h" // for UniqueId #include "SynTree/Type.h" // for Type, Type::StorageClasses, Type::Fu... @@ -43,9 +43,9 @@ bool extension = false; - Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage ); - Declaration( const Declaration &other ); + Declaration( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage ); + Declaration( const Declaration & other ); virtual ~Declaration(); - const std::string &get_name() const { return name; } + const std::string & get_name() const { return name; } void set_name( std::string newValue ) { name = newValue; } @@ -58,13 +58,13 @@ bool get_extension() const { return extension; } - Declaration *set_extension( bool exten ) { extension = exten; return this; } + Declaration * set_extension( bool exten ) { extension = exten; return this; } void fixUniqueId( void ); - virtual Declaration *clone() const override = 0; + virtual Declaration * clone() const override = 0; virtual void accept( Visitor & v ) override = 0; virtual void accept( Visitor & v ) const override = 0; - virtual Declaration *acceptMutator( Mutator &m ) override = 0; - virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0; - virtual void printShort( std::ostream &os, Indenter indent = {} ) const = 0; + virtual Declaration * acceptMutator( Mutator & m ) override = 0; + virtual void print( std::ostream & os, Indenter indent = {} ) const override = 0; + virtual void printShort( std::ostream & os, Indenter indent = {} ) const = 0; UniqueId uniqueId; @@ -80,10 +80,10 @@ int scopeLevel = 0; - Expression *asmName; + 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 ); - DeclarationWithType( const DeclarationWithType &other ); + 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(); @@ -96,6 +96,6 @@ DeclarationWithType * set_scopeLevel( int newValue ) { scopeLevel = newValue; return this; } - Expression *get_asmName() const { return asmName; } - DeclarationWithType * set_asmName( Expression *newValue ) { asmName = newValue; return this; } + Expression * get_asmName() const { return asmName; } + DeclarationWithType * set_asmName( Expression * newValue ) { asmName = newValue; return this; } std::list< Attribute * >& get_attributes() { return attributes; } @@ -105,6 +105,6 @@ //void set_functionSpecifiers( Type::FuncSpecifiers newValue ) { fs = newValue; } - virtual DeclarationWithType *clone() const override = 0; - virtual DeclarationWithType *acceptMutator( Mutator &m ) override = 0; + virtual DeclarationWithType * clone() const override = 0; + virtual DeclarationWithType * acceptMutator( Mutator & m ) override = 0; virtual Type * get_type() const = 0; @@ -118,30 +118,30 @@ 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, + 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() ); - ObjectDecl( const ObjectDecl &other ); + ObjectDecl( const ObjectDecl & other ); virtual ~ObjectDecl(); virtual Type * get_type() const override { return type; } - virtual void set_type(Type *newType) override { type = newType; } - - Initializer *get_init() const { return init; } - void set_init( Initializer *newValue ) { init = newValue; } - - Expression *get_bitfieldWidth() const { return bitfieldWidth; } - void set_bitfieldWidth( Expression *newValue ) { bitfieldWidth = newValue; } + virtual void set_type(Type * newType) override { type = newType; } + + Initializer * get_init() const { return init; } + void set_init( Initializer * newValue ) { init = newValue; } + + Expression * get_bitfieldWidth() const { return bitfieldWidth; } + void set_bitfieldWidth( Expression * newValue ) { bitfieldWidth = newValue; } static ObjectDecl * newObject( const std::string & name, Type * type, Initializer * init ); - virtual ObjectDecl *clone() const override { return new ObjectDecl( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual DeclarationWithType *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; + virtual ObjectDecl * clone() const override { return new ObjectDecl( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual DeclarationWithType * 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; }; @@ -149,11 +149,11 @@ typedef DeclarationWithType Parent; public: - FunctionType *type; - CompoundStmt *statements; + FunctionType * type; + CompoundStmt * statements; std::list< Expression * > withExprs; - FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, 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() ); - FunctionDecl( const FunctionDecl &other ); + FunctionDecl( const FunctionDecl & other ); virtual ~FunctionDecl(); @@ -162,17 +162,17 @@ FunctionType * get_functionType() const { return type; } - void set_functionType( FunctionType *newValue ) { type = newValue; } - CompoundStmt *get_statements() const { return statements; } - void set_statements( CompoundStmt *newValue ) { statements = newValue; } + void set_functionType( FunctionType * newValue ) { type = newValue; } + CompoundStmt * get_statements() const { return statements; } + void set_statements( CompoundStmt * newValue ) { statements = newValue; } bool has_body() const { return NULL != statements; } static FunctionDecl * newFunction( const std::string & name, FunctionType * type, CompoundStmt * statements ); - virtual FunctionDecl *clone() const override { return new FunctionDecl( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual DeclarationWithType *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; + virtual FunctionDecl * clone() const override { return new FunctionDecl( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual DeclarationWithType * 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; }; @@ -180,22 +180,22 @@ 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 ); + Type * base; + std::list< TypeDecl * > parameters; + std::list< DeclarationWithType * > assertions; + + NamedTypeDecl( const std::string & name, Type::StorageClasses scs, Type * type ); + NamedTypeDecl( const NamedTypeDecl & other ); virtual ~NamedTypeDecl(); - Type *get_base() const { return base; } - void set_base( Type *newValue ) { base = newValue; } - std::list< TypeDecl* >& get_parameters() { return parameters; } - std::list< DeclarationWithType* >& get_assertions() { return assertions; } + Type * get_base() const { return base; } + void set_base( Type * newValue ) { base = newValue; } + std::list< TypeDecl* > & get_parameters() { return parameters; } + std::list< DeclarationWithType * >& get_assertions() { return assertions; } virtual const char * typeString() const = 0; - virtual NamedTypeDecl *clone() const override = 0; - virtual void print( std::ostream &os, Indenter indent = {} ) const override; - virtual void printShort( std::ostream &os, Indenter indent = {} ) const override; + virtual NamedTypeDecl * clone() const override = 0; + virtual void print( std::ostream & os, Indenter indent = {} ) const override; + virtual void printShort( std::ostream & os, Indenter indent = {} ) const override; }; @@ -203,26 +203,27 @@ typedef NamedTypeDecl Parent; public: - enum Kind { Dtype, Ftype, Ttype, NUMBER_OF_KINDS }; - + enum Kind { Dtype, Otype, Ftype, Ttype, NUMBER_OF_KINDS }; + + Kind kind; + bool sized; Type * init; - bool sized; /// Data extracted from a type decl struct Data { - TypeDecl::Kind kind; + Kind kind; bool isComplete; - Data() : kind( (TypeDecl::Kind)-1 ), isComplete( false ) {} - Data( TypeDecl * typeDecl ) : Data( typeDecl->get_kind(), typeDecl->isComplete() ) {} + Data() : kind( NUMBER_OF_KINDS ), isComplete( false ) {} + Data( const TypeDecl * typeDecl ) : Data( typeDecl->get_kind(), typeDecl->isComplete() ) {} Data( Kind kind, bool isComplete ) : kind( kind ), isComplete( isComplete ) {} - Data( const Data& d1, const Data& d2 ) - : kind( d1.kind ), isComplete ( d1.isComplete || d2.isComplete ) {} - - bool operator==(const Data & other) const { return kind == other.kind && isComplete == other.isComplete; } - bool operator!=(const Data & other) const { return !(*this == other);} + Data( const Data & d1, const Data & d2 ) + : kind( d1.kind ), isComplete( d1.isComplete || d2.isComplete ) {} + + bool operator==( const Data & other ) const { return kind == other.kind && isComplete == other.isComplete; } + bool operator!=( const Data & other ) const { return !(*this == other);} }; - TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, bool sized, Type * init = nullptr ); - TypeDecl( const TypeDecl &other ); + TypeDecl( const std::string & name, Type::StorageClasses scs, Type * type, Kind kind, bool sized, Type * init = nullptr ); + TypeDecl( const TypeDecl & other ); virtual ~TypeDecl(); @@ -239,11 +240,9 @@ virtual const char * genTypeString() const; - virtual TypeDecl *clone() const override { return new TypeDecl( *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 ); } - virtual void print( std::ostream &os, Indenter indent = {} ) const override; - - Kind kind; + virtual TypeDecl * clone() const override { return new TypeDecl( *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 ); } + virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -251,15 +250,15 @@ typedef NamedTypeDecl Parent; public: - TypedefDecl( const std::string &name, CodeLocation location, Type::StorageClasses scs, Type *type, LinkageSpec::Spec spec = LinkageSpec::Cforall ) + TypedefDecl( const std::string & name, CodeLocation location, Type::StorageClasses scs, Type * type, LinkageSpec::Spec spec = LinkageSpec::Cforall ) : Parent( name, scs, type ) { set_linkage( spec ); this->location = location; } - TypedefDecl( const TypedefDecl &other ) : Parent( other ) {} - - virtual const char * typeString() const override; - - virtual TypedefDecl *clone() const override { return new TypedefDecl( *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 ); } + TypedefDecl( const TypedefDecl & other ) : Parent( other ) {} + + virtual const char * typeString() const override; + + virtual TypedefDecl * clone() const override { return new TypedefDecl( *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 ); } private: }; @@ -277,6 +276,6 @@ AggregateDecl * parent = nullptr; - AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ); - AggregateDecl( const AggregateDecl &other ); + 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(); @@ -290,6 +289,6 @@ AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; } - virtual void print( std::ostream &os, Indenter indent = {} ) const override final; - virtual void printShort( std::ostream &os, Indenter indent = {} ) const override; + virtual void print( std::ostream & os, Indenter indent = {} ) const override final; + virtual void printShort( std::ostream & os, Indenter indent = {} ) const override; protected: virtual const char * typeString() const = 0; @@ -299,6 +298,6 @@ typedef AggregateDecl Parent; public: - StructDecl( const std::string &name, Aggregate kind = Struct, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( kind ) {} - StructDecl( const StructDecl &other ) : Parent( other ), kind( other.kind ) {} + StructDecl( const std::string & name, Aggregate kind = Struct, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( kind ) {} + StructDecl( const StructDecl & other ) : Parent( other ), kind( other.kind ) {} bool is_coroutine() { return kind == Coroutine; } @@ -306,8 +305,8 @@ bool is_thread() { return kind == Thread; } - virtual StructDecl *clone() const override { return new StructDecl( *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 ); } + virtual StructDecl * clone() const override { return new StructDecl( *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 ); } Aggregate kind; private: @@ -318,11 +317,11 @@ typedef AggregateDecl Parent; public: - UnionDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {} - UnionDecl( const UnionDecl &other ) : Parent( other ) {} - - virtual UnionDecl *clone() const override { return new UnionDecl( *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 ); } + UnionDecl( const std::string & name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {} + UnionDecl( const UnionDecl & other ) : Parent( other ) {} + + virtual UnionDecl * clone() const override { return new UnionDecl( *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 ); } private: virtual const char * typeString() const override; @@ -332,13 +331,13 @@ typedef AggregateDecl Parent; public: - EnumDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {} - EnumDecl( const EnumDecl &other ) : Parent( other ) {} + EnumDecl( const std::string & name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {} + EnumDecl( const EnumDecl & other ) : Parent( other ) {} 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 ); } + 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 ); } private: std::unordered_map< std::string, long long int > enumValues; @@ -349,13 +348,13 @@ typedef AggregateDecl Parent; public: - TraitDecl( const std::string &name, const std::list< Attribute * > & attributes, LinkageSpec::Spec linkage ) : Parent( name, attributes, linkage ) { + TraitDecl( const std::string & name, const std::list< Attribute * > & attributes, LinkageSpec::Spec linkage ) : Parent( name, attributes, linkage ) { assertf( attributes.empty(), "attribute unsupported for traits" ); } - TraitDecl( const TraitDecl &other ) : Parent( other ) {} - - virtual TraitDecl *clone() const override { return new TraitDecl( *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 ); } + TraitDecl( const TraitDecl & other ) : Parent( other ) {} + + virtual TraitDecl * clone() const override { return new TraitDecl( *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 ); } private: virtual const char * typeString() const override; @@ -381,19 +380,19 @@ class AsmDecl : public Declaration { public: - AsmStmt *stmt; - - AsmDecl( AsmStmt *stmt ); - AsmDecl( const AsmDecl &other ); + AsmStmt * stmt; + + AsmDecl( AsmStmt * stmt ); + AsmDecl( const AsmDecl & other ); virtual ~AsmDecl(); - AsmStmt *get_stmt() { return stmt; } - void set_stmt( AsmStmt *newValue ) { stmt = newValue; } - - virtual AsmDecl *clone() const override { return new AsmDecl( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual AsmDecl *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; + AsmStmt * get_stmt() { return stmt; } + void set_stmt( AsmStmt * newValue ) { stmt = newValue; } + + virtual AsmDecl * clone() const override { return new AsmDecl( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual AsmDecl * 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; }; @@ -410,7 +409,7 @@ virtual void accept( Visitor & v ) override { v.visit( this ); } virtual void accept( Visitor & v ) const 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; + 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; }; Index: src/SynTree/DeclarationWithType.cc =================================================================== --- src/SynTree/DeclarationWithType.cc (revision cfaa2873f31b6edf27dbf9fb7a544ce6a7bb2a93) +++ src/SynTree/DeclarationWithType.cc (revision bffcd663a600d87ff5b237df6c2c43c0d99f2c02) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Mar 16 08:34:35 2017 -// Update Count : 25 +// Last Modified On : Fri Dec 13 23:45:16 2019 +// Update Count : 26 // @@ -20,6 +20,6 @@ #include "Common/utility.h" // for cloneAll, deleteAll, maybeClone #include "Declaration.h" // for DeclarationWithType, Declaration -#include "Parser/LinkageSpec.h" // for Spec -#include "SynTree/Expression.h" // for ConstantExpr +#include "LinkageSpec.h" // for Spec +#include "Expression.h" // for ConstantExpr #include "Type.h" // for Type, Type::FuncSpecifiers, Type::St... Index: src/SynTree/FunctionDecl.cc =================================================================== --- src/SynTree/FunctionDecl.cc (revision cfaa2873f31b6edf27dbf9fb7a544ce6a7bb2a93) +++ src/SynTree/FunctionDecl.cc (revision bffcd663a600d87ff5b237df6c2c43c0d99f2c02) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Dec 7 17:40:09 2019 -// Update Count : 75 +// Last Modified On : Fri Dec 13 23:10:34 2019 +// Update Count : 76 // @@ -24,5 +24,5 @@ #include "Declaration.h" // for FunctionDecl, FunctionDecl::Parent #include "Expression.h" -#include "Parser/LinkageSpec.h" // for Spec, linkageName, Cforall +#include "LinkageSpec.h" // for Spec, linkageName, Cforall #include "Statement.h" // for CompoundStmt #include "Type.h" // for Type, FunctionType, Type::FuncSpecif... Index: src/SynTree/LinkageSpec.cc =================================================================== --- src/SynTree/LinkageSpec.cc (revision bffcd663a600d87ff5b237df6c2c43c0d99f2c02) +++ src/SynTree/LinkageSpec.cc (revision bffcd663a600d87ff5b237df6c2c43c0d99f2c02) @@ -0,0 +1,67 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// LinkageSpec.cc -- +// +// Author : Rodolfo G. Esteves +// Created On : Sat May 16 13:22:09 2015 +// Last Modified By : Andrew Beach +// Last Modified On : Thr Spt 12 15:59:00 2018 +// Update Count : 26 +// + +#include +#include +#include +using namespace std; + +#include "LinkageSpec.h" +#include "Common/SemanticError.h" + +namespace LinkageSpec { + +Spec linkageUpdate( CodeLocation location, Spec old_spec, const string * cmd ) { + assert( cmd ); + unique_ptr guard( cmd ); // allocated by lexer + if ( *cmd == "\"Cforall\"" ) { + old_spec.is_mangled = true; + return old_spec; + } else if ( *cmd == "\"C\"" ) { + old_spec.is_mangled = false; + return old_spec; + } else { + SemanticError( location, "Invalid linkage specifier " + *cmd ); + } // if +} + +std::string linkageName( Spec linkage ) { + switch ( linkage ) { + case Intrinsic: + return "intrinsic"; + case C: + return "C"; + case Cforall: + return "Cforall"; + case AutoGen: + return "autogenerated cfa"; + case Compiler: + return "compiler built-in"; + case BuiltinCFA: + return "cfa built-in"; + case BuiltinC: + return "c built-in"; + default: + return ""; + } +} + +} // LinkageSpec + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/SynTree/LinkageSpec.h =================================================================== --- src/SynTree/LinkageSpec.h (revision bffcd663a600d87ff5b237df6c2c43c0d99f2c02) +++ src/SynTree/LinkageSpec.h (revision bffcd663a600d87ff5b237df6c2c43c0d99f2c02) @@ -0,0 +1,79 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// LinkageSpec.h -- +// +// Author : Rodolfo G. Esteves +// Created On : Sat May 16 13:24:28 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Wed Jul 10 16:02:34 2019 +// Update Count : 18 +// + +#pragma once + +#include + +#include "Common/CodeLocation.h" + +namespace LinkageSpec { + // All linkage specs are some combination of these flags: + enum { Mangle = 1 << 0, Generate = 1 << 1, Overrideable = 1 << 2, Builtin = 1 << 3, GccBuiltin = 1 << 4, NoOfSpecs = 1 << 5, }; + + union Spec { + unsigned int val; + struct { + bool is_mangled : 1; + bool is_generatable : 1; + bool is_overridable : 1; + bool is_builtin : 1; + bool is_gcc_builtin : 1; + }; + constexpr Spec( unsigned int val ) : val( val ) {} + constexpr Spec( Spec const & other ) : val( other.val ) {} + constexpr Spec & operator=( const Spec & ) = default; + // Operators may go here. + // Supports == and != + constexpr operator unsigned int() const { return val; } + }; + + + Spec linkageUpdate( CodeLocation location, Spec old_spec, const std::string * cmd ); + /* If cmd = "C" returns a Spec that is old_spec with is_mangled = false + * If cmd = "Cforall" returns old_spec Spec with is_mangled = true + */ + + std::string linkageName( Spec ); + + // To Update: LinkageSpec::isXyz( cur_spec ) -> cur_spec.is_xyz + inline bool isMangled( Spec spec ) { return spec.is_mangled; } + inline bool isGeneratable( Spec spec ) { return spec.is_generatable; } + inline bool isOverridable( Spec spec ) { return spec.is_overridable; } + inline bool isBuiltin( Spec spec ) { return spec.is_builtin; } + inline bool isGccBuiltin( Spec spec ) { return spec.is_gcc_builtin; } + + // Pre-defined flag combinations: + // C built-in defined in prelude + constexpr Spec const Intrinsic = { Mangle | Generate | Overrideable | Builtin }; + // ordinary + constexpr Spec const Cforall = { Mangle | Generate }; + // not overloadable, not mangled + constexpr Spec const C = { Generate }; + // built by translator (struct assignment) + constexpr Spec const AutoGen = { Mangle | Generate | Overrideable }; + // gcc internal + constexpr Spec const Compiler = { Mangle | Builtin | GccBuiltin }; + // mangled builtins + constexpr Spec const BuiltinCFA = { Mangle | Generate | Builtin }; + // non-mangled builtins + constexpr Spec const BuiltinC = { Generate | Builtin }; +}; + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/SynTree/NamedTypeDecl.cc =================================================================== --- src/SynTree/NamedTypeDecl.cc (revision cfaa2873f31b6edf27dbf9fb7a544ce6a7bb2a93) +++ src/SynTree/NamedTypeDecl.cc (revision bffcd663a600d87ff5b237df6c2c43c0d99f2c02) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Dec 11 08:26:17 2019 -// Update Count : 15 +// Last Modified On : Fri Dec 13 23:44:24 2019 +// Update Count : 16 // @@ -20,5 +20,5 @@ #include "Common/utility.h" // for printAll, cloneAll, deleteAll, maybe... #include "Declaration.h" // for NamedTypeDecl, DeclarationWithType -#include "Parser/LinkageSpec.h" // for Spec, Cforall, linkageName +#include "LinkageSpec.h" // for Spec, Cforall, linkageName #include "Type.h" // for Type, Type::StorageClasses Index: src/SynTree/ObjectDecl.cc =================================================================== --- src/SynTree/ObjectDecl.cc (revision cfaa2873f31b6edf27dbf9fb7a544ce6a7bb2a93) +++ src/SynTree/ObjectDecl.cc (revision bffcd663a600d87ff5b237df6c2c43c0d99f2c02) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Mar 16 08:34:27 2017 -// Update Count : 59 +// Last Modified On : Fri Dec 13 23:44:50 2019 +// Update Count : 60 // @@ -23,5 +23,5 @@ #include "Expression.h" // for Expression #include "Initializer.h" // for Initializer -#include "Parser/LinkageSpec.h" // for Spec, linkageName, Cforall +#include "LinkageSpec.h" // for Spec, linkageName, Cforall #include "Type.h" // for Type, Type::StorageClasses, Type::Fu... Index: src/SynTree/TupleType.cc =================================================================== --- src/SynTree/TupleType.cc (revision cfaa2873f31b6edf27dbf9fb7a544ce6a7bb2a93) +++ src/SynTree/TupleType.cc (revision bffcd663a600d87ff5b237df6c2c43c0d99f2c02) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Feb 1 17:10:58 2017 -// Update Count : 3 +// Last Modified On : Fri Dec 13 23:44:38 2019 +// Update Count : 4 // @@ -20,5 +20,5 @@ #include "Declaration.h" // for Declaration, ObjectDecl #include "Initializer.h" // for ListInit -#include "Parser/LinkageSpec.h" // for Cforall +#include "LinkageSpec.h" // for Cforall #include "Type.h" // for TupleType, Type, Type::Qualifiers Index: src/SynTree/TypeDecl.cc =================================================================== --- src/SynTree/TypeDecl.cc (revision cfaa2873f31b6edf27dbf9fb7a544ce6a7bb2a93) +++ src/SynTree/TypeDecl.cc (revision bffcd663a600d87ff5b237df6c2c43c0d99f2c02) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Dec 11 17:56:30 2019 -// Update Count : 10 +// Last Modified On : Fri Dec 13 15:26:14 2019 +// Update Count : 21 // @@ -18,43 +18,41 @@ #include "Common/utility.h" // for maybeClone -#include "Parser/ParseNode.h" #include "Declaration.h" // for TypeDecl, TypeDecl::Data, TypeDecl::Kind... #include "Type.h" // for Type, Type::StorageClasses -TypeDecl::TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, bool sized, Type * init ) : Parent( name, scs, type ), init( init ), sized( kind == Ttype || sized ), kind( kind ) { +TypeDecl::TypeDecl( const std::string & name, Type::StorageClasses scs, Type * type, Kind kind, bool sized, Type * init ) : Parent( name, scs, type ), kind( kind ), sized( kind == Ttype || sized ), init( init ) { } -TypeDecl::TypeDecl( const TypeDecl &other ) : Parent( other ), init( maybeClone( other.init ) ), sized( other.sized ), kind( other.kind ) { +TypeDecl::TypeDecl( const TypeDecl & other ) : Parent( other ), kind( other.kind ), sized( other.sized ), init( maybeClone( other.init ) ) { } TypeDecl::~TypeDecl() { - delete init; + delete init; } const char * TypeDecl::typeString() const { - static const char * kindNames[] = { "sized object type", "sized function type", "sized tuple type" }; - assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1, "typeString: kindNames is out of sync." ); - assertf( kind < sizeof(kindNames)/sizeof(kindNames[0]), "TypeDecl's kind is out of bounds." ); + static const char * kindNames[] = { "sized data type", "sized object type", "sized function type", "sized tuple type" }; + static_assert( sizeof(kindNames)/sizeof(kindNames[0]) == TypeDecl::NUMBER_OF_KINDS, "typeString: kindNames is out of sync." ); + assertf( kind < TypeDecl::NUMBER_OF_KINDS, "TypeDecl kind is out of bounds." ); return isComplete() ? kindNames[ kind ] : &kindNames[ kind ][ sizeof("sized") ]; // sizeof includes '\0' } const char * TypeDecl::genTypeString() const { - static const char * kindNames[] = { "dtype", "ftype", "ttype" }; - assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1, "genTypeString: kindNames is out of sync." ); - assertf( kind < sizeof(kindNames)/sizeof(kindNames[0]), "TypeDecl's kind is out of bounds." ); + static const char * kindNames[] = { "dtype", "otype", "ftype", "ttype" }; + static_assert( sizeof(kindNames)/sizeof(kindNames[0]) == TypeDecl::NUMBER_OF_KINDS, "genTypeString: kindNames is out of sync." ); + assertf( kind < TypeDecl::NUMBER_OF_KINDS, "TypeDecl kind is out of bounds." ); return kindNames[ kind ]; } void TypeDecl::print( std::ostream &os, Indenter indent ) const { - NamedTypeDecl::print( os, indent ); - if ( init ) { - os << std::endl << indent << "with type initializer: "; - init->print( os, indent + 1 ); - } + NamedTypeDecl::print( os, indent ); + if ( init ) { + os << std::endl << indent << "with type initializer: "; + init->print( os, indent + 1 ); + } // if } - std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data ) { - return os << data.kind << ", " << data.isComplete; + return os << data.kind << ", " << data.isComplete; } Index: src/SynTree/module.mk =================================================================== --- src/SynTree/module.mk (revision cfaa2873f31b6edf27dbf9fb7a544ce6a7bb2a93) +++ src/SynTree/module.mk (revision bffcd663a600d87ff5b237df6c2c43c0d99f2c02) @@ -11,43 +11,44 @@ ## Created On : Mon Jun 1 17:49:17 2015 ## Last Modified By : Peter A. Buhr -## Last Modified On : Mon Jun 1 17:54:09 2015 -## Update Count : 1 +## Last Modified On : Sat Dec 14 07:26:43 2019 +## Update Count : 2 ############################################################################### SRC_SYNTREE = \ - SynTree/Type.cc \ - SynTree/VoidType.cc \ + SynTree/AddressExpr.cc \ + SynTree/AggregateDecl.cc \ + SynTree/ApplicationExpr.cc \ + SynTree/ArrayType.cc \ + SynTree/AttrType.cc \ + SynTree/Attribute.cc \ SynTree/BasicType.cc \ - SynTree/PointerType.cc \ - SynTree/ArrayType.cc \ - SynTree/ReferenceType.cc \ - SynTree/FunctionType.cc \ - SynTree/ReferenceToType.cc \ - SynTree/TupleType.cc \ - SynTree/TypeofType.cc \ - SynTree/AttrType.cc \ - SynTree/VarArgsType.cc \ - SynTree/ZeroOneType.cc \ + SynTree/CommaExpr.cc \ + SynTree/CompoundStmt.cc \ SynTree/Constant.cc \ - SynTree/Expression.cc \ - SynTree/TupleExpr.cc \ - SynTree/CommaExpr.cc \ - SynTree/TypeExpr.cc \ - SynTree/ApplicationExpr.cc \ - SynTree/AddressExpr.cc \ - SynTree/Statement.cc \ - SynTree/CompoundStmt.cc \ + SynTree/DeclReplacer.cc \ SynTree/DeclStmt.cc \ SynTree/Declaration.cc \ SynTree/DeclarationWithType.cc \ + SynTree/Expression.cc \ + SynTree/FunctionDecl.cc \ + SynTree/FunctionType.cc \ + SynTree/Initializer.cc \ + SynTree/LinkageSpec.cc \ + SynTree/NamedTypeDecl.cc \ SynTree/ObjectDecl.cc \ - SynTree/FunctionDecl.cc \ - SynTree/AggregateDecl.cc \ - SynTree/NamedTypeDecl.cc \ + SynTree/PointerType.cc \ + SynTree/ReferenceToType.cc \ + SynTree/ReferenceType.cc \ + SynTree/Statement.cc \ + SynTree/TupleExpr.cc \ + SynTree/TupleType.cc \ + SynTree/Type.cc \ SynTree/TypeDecl.cc \ - SynTree/Initializer.cc \ + SynTree/TypeExpr.cc \ SynTree/TypeSubstitution.cc \ - SynTree/Attribute.cc \ - SynTree/DeclReplacer.cc + SynTree/TypeofType.cc \ + SynTree/VarArgsType.cc \ + SynTree/VoidType.cc \ + SynTree/ZeroOneType.cc SRC += $(SRC_SYNTREE)