Changeset 1fb7bfd


Ignore:
Timestamp:
May 16, 2019, 1:55:48 PM (2 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, cleanup-dtors, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
87701b6
Parents:
8133121 (diff), 24afc53 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:
src
Files:
1 added
11 edited

Legend:

Unmodified
Added
Removed
  • src/AST/CVQualifiers.hpp

    r8133121 r1fb7bfd  
    5959        // ordering is a subtype relationship over qualifiers, e.g. `int` => `const int` is free
    6060
    61         bool operator== ( Qualifiers a, Qualifiers b ) {
     61        inline bool operator== ( Qualifiers a, Qualifiers b ) {
    6262                return (a.val & EquivQualifiers) == (b.val & EquivQualifiers);
    6363        }
    64         bool operator!= ( Qualifiers a, Qualifiers b ) {
     64        inline bool operator!= ( Qualifiers a, Qualifiers b ) {
    6565                return !(a == b);
    6666        }
    67         bool operator<= ( Qualifiers a, Qualifiers b ) {
     67        inline bool operator<= ( Qualifiers a, Qualifiers b ) {
    6868                return a.is_const    <= b.is_const    // non-const converts to const for free
    6969                        && a.is_volatile <= b.is_volatile // non-volatile converts to volatile for free
     
    7171                        && a.is_atomic   == b.is_atomic;  // atomicity must be preserved in free conversion
    7272        }
    73         bool operator<  ( Qualifiers a, Qualifiers b ) { return a != b && a <= b; }
    74         bool operator>= ( Qualifiers a, Qualifiers b ) { return b <= a; }
    75         bool operator>  ( Qualifiers a, Qualifiers b ) { return b < a; }
     73        inline bool operator<  ( Qualifiers a, Qualifiers b ) { return a != b && a <= b; }
     74        inline bool operator>= ( Qualifiers a, Qualifiers b ) { return b <= a; }
     75        inline bool operator>  ( Qualifiers a, Qualifiers b ) { return b < a; }
    7676
    7777}
  • src/AST/Convert.cpp

    r8133121 r1fb7bfd  
    413413        }
    414414
    415         virtual void visit( AttrExpr * ) override final {
    416 
    417         }
    418 
    419415        virtual void visit( LogicalExpr * ) override final {
    420416
  • src/AST/Decl.hpp

    r8133121 r1fb7bfd  
    3232namespace ast {
    3333
    34 class Attribute;
    35 class Expr;
    36 class Init;
    37 class TypeDecl;
    38 
    3934/// Base declaration class
    4035class Decl : public ParseNode {
     
    150145public:
    151146        ptr<Type> base;
    152         std::vector<ptr<TypeDecl>> parameters;
     147        std::vector<ptr<TypeDecl>> params;
    153148        std::vector<ptr<DeclWithType>> assertions;
    154149
    155150        NamedTypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage,
    156151                Type* b, Linkage::Spec spec = Linkage::Cforall )
    157         : Decl( loc, name, storage, spec ), base( b ), parameters(), assertions() {}
     152        : Decl( loc, name, storage, spec ), base( b ), params(), assertions() {}
    158153
    159154        /// Produces a name for the kind of alias
     
    231226public:
    232227        std::vector<ptr<Decl>> members;
    233         std::vector<ptr<TypeDecl>> parameters;
     228        std::vector<ptr<TypeDecl>> params;
    234229        std::vector<ptr<Attribute>> attributes;
    235230        bool body = false;
     
    238233        AggregateDecl( const CodeLocation& loc, const std::string& name,
    239234                std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall )
    240         : Decl( loc, name, Storage::Classes{}, linkage ), members(), parameters(),
     235        : Decl( loc, name, Storage::Classes{}, linkage ), members(), params(),
    241236          attributes( std::move(attrs) ) {}
    242237
  • src/AST/Expr.hpp

    r8133121 r1fb7bfd  
    1818#include <cassert>
    1919#include <map>
     20#include <string>
    2021#include <utility>        // for move
    2122#include <vector>
    2223
    2324#include "Fwd.hpp"        // for UniqueId
     25#include "Label.hpp"
    2426#include "ParseNode.hpp"
    2527#include "Visitor.hpp"
     
    117119        bool extension = false;
    118120
    119         Expr(const CodeLocation & loc ) : ParseNode( loc ), result(), env(), inferred() {}
     121        Expr( const CodeLocation & loc, const Type * res = nullptr )
     122        : ParseNode( loc ), result( res ), env(), inferred() {}
    120123
    121124        Expr * set_extension( bool ex ) { extension = ex; return this; }
     
    124127private:
    125128        Expr * clone() const override = 0;
     129};
     130
     131/// The application of a function to a set of parameters.
     132/// Post-resolver form of `UntypedExpr`
     133class ApplicationExpr final : public Expr {
     134public:
     135        ptr<Expr> func;
     136        std::vector<ptr<Expr>> args;
     137
     138        ApplicationExpr( const CodeLocation & loc, const Expr * f, std::vector<ptr<Expr>> && as = {} );
     139
     140        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     141private:
     142        ApplicationExpr * clone() const override { return new ApplicationExpr{ *this }; }
     143};
     144
     145/// The application of a function to a set of parameters, pre-overload resolution.
     146class UntypedExpr final : public Expr {
     147public:
     148        ptr<Expr> func;
     149        std::vector<ptr<Expr>> args;
     150
     151        UntypedExpr( const CodeLocation & loc, const Expr * f, std::vector<ptr<Expr>> && as = {} )
     152        : Expr( loc ), func( f ), args( std::move(as) ) {}
     153
     154        /// Creates a new dereference expression
     155        static UntypedExpr * createDeref( const CodeLocation & loc, Expr * arg );
     156        /// Creates a new assignment expression
     157        static UntypedExpr * createAssign( const CodeLocation & loc, Expr * lhs, Expr * rhs );
     158
     159        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     160private:
     161        UntypedExpr * clone() const override { return new UntypedExpr{ *this }; }
     162};
     163
     164/// A name whose name is as-yet undetermined.
     165/// May also be used to avoid name mangling in codegen phase.
     166class NameExpr final : public Expr {
     167public:
     168        std::string name;
     169
     170        NameExpr( const CodeLocation & loc, const std::string & n ) : Expr( loc ), name( n ) {}
     171
     172        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     173private:
     174        NameExpr * clone() const override { return new NameExpr{ *this }; }
     175};
     176
     177/// Address-of expression `&e`
     178class AddressExpr final : public Expr {
     179public:
     180        ptr<Expr> arg;
     181
     182        AddressExpr( const CodeLocation & loc, const Expr * a );
     183
     184        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     185private:
     186        AddressExpr * clone() const override { return new AddressExpr{ *this }; }
     187};
     188
     189/// GCC &&label
     190/// https://gcc.gnu.org/onlinedocs/gcc-3.4.2/gcc/Labels-as-Values.html
     191class LabelAddressExpr final : public Expr {
     192public:
     193        Label arg;
     194
     195        LabelAddressExpr( const CodeLocation & loc, Label && a );
     196
     197        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     198private:
     199        LabelAddressExpr * clone() const override { return new LabelAddressExpr{ *this }; }
     200};
     201
     202/// Whether a cast existed in the program source or not
     203enum GeneratedFlag { ExplicitCast, GeneratedCast };
     204
     205/// A type cast, e.g. `(int)e`
     206class CastExpr final : public Expr {
     207public:
     208        ptr<Expr> arg;
     209        GeneratedFlag isGenerated;
     210
     211        CastExpr( const CodeLocation & loc, const Expr * a, const Type * to,
     212                GeneratedFlag g = GeneratedCast ) : Expr( loc, to ), arg( a ), isGenerated( g ) {}
     213        /// Cast-to-void
     214        CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g = GeneratedCast );
     215
     216        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     217private:
     218        CastExpr * clone() const override { return new CastExpr{ *this }; }
     219};
     220
     221/// A cast to "keyword types", e.g. `(thread &)t`
     222class KeywordCastExpr final : public Expr {
     223public:
     224        ptr<Expr> arg;
     225        enum Target { Coroutine, Thread, Monitor, NUMBER_OF_TARGETS } target;
     226
     227        KeywordCastExpr( const CodeLocation & loc, const Expr * a, Target t )
     228        : Expr( loc ), arg( a ), target( t ) {}
     229
     230        /// Get a name for the target type
     231        const std::string& targetString() const;
     232
     233        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     234private:
     235        KeywordCastExpr * clone() const override { return new KeywordCastExpr{ *this }; }
     236};
     237
     238/// A virtual dynamic cast, e.g. `(virtual exception)e`
     239class VirtualCastExpr final : public Expr {
     240public:
     241        ptr<Expr> arg;
     242
     243        VirtualCastExpr( const CodeLocation & loc, const Expr * a, const Type * to )
     244        : Expr( loc, to ), arg( a ) {}
     245
     246        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     247private:
     248        VirtualCastExpr * clone() const override { return new VirtualCastExpr{ *this }; }
     249};
     250
     251/// A member selection operation before expression resolution, e.g. `q.p`
     252class UntypedMemberExpr final : public Expr {
     253public:
     254        ptr<Expr> member;
     255        ptr<Expr> aggregate;
     256
     257        UntypedMemberExpr( const CodeLocation & loc, const Expr * mem, const Expr * agg )
     258        : Expr( loc ), member( mem ), aggregate( agg ) { assert( aggregate ); }
     259
     260        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     261private:
     262        UntypedMemberExpr * clone() const override { return new UntypedMemberExpr{ *this }; }
     263};
     264
     265/// A member selection operation after expression resolution, e.g. `q.p`
     266class MemberExpr final : public Expr {
     267public:
     268        readonly<DeclWithType> member;
     269        ptr<Expr> aggregate;
     270
     271        MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg );
     272
     273        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     274private:
     275        MemberExpr * clone() const override { return new MemberExpr{ *this }; }
     276};
     277
     278/// A reference to a named variable.
     279class VariableExpr final : public Expr {
     280public:
     281        readonly<DeclWithType> var;
     282
     283        VariableExpr( const CodeLocation & loc, const DeclWithType * v );
     284
     285        /// generates a function pointer for a given function
     286        static VariableExpr * functionPointer( const CodeLocation & loc, const FunctionDecl * decl );
     287
     288        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     289private:
     290        VariableExpr * clone() const override { return new VariableExpr{ *this }; }
     291};
     292
     293/// A compile-time constant
     294class ConstantExpr final : public Expr {
     295        union Val {
     296                unsigned long long ival;
     297                double dval;
     298               
     299                Val( unsigned long long i ) : ival( i ) {}
     300                Val( double d ) : dval( d ) {}
     301        } val;
     302public:
     303        std::string rep;
     304
     305        ConstantExpr(
     306                const CodeLocation & loc, const Type * ty, const std::string & r, unsigned long long v )
     307        : Expr( loc, ty ), val( v ), rep( r ) {}
     308        ConstantExpr( const CodeLocation & loc, const Type * ty, const std::string & r, double v )
     309        : Expr( loc, ty ), val( v ), rep( r ) {}
     310       
     311        /// Gets the value of this constant as an integer
     312        long long int intValue() const;
     313        /// Gets the value of this constant as floating point
     314        double floatValue() const;
     315
     316        /// generates a boolean constant of the given bool
     317        static ConstantExpr * from_bool( const CodeLocation & loc, bool b );
     318        /// generates a char constant of the given char
     319        static ConstantExpr * from_char( const CodeLocation & loc, char c );
     320        /// generates an integer constant of the given int
     321        static ConstantExpr * from_int( const CodeLocation & loc, int i );
     322        /// generates an integer constant of the given unsigned long int
     323        static ConstantExpr * from_ulong( const CodeLocation & loc, unsigned long i );
     324        /// generates a floating point constant of the given double
     325        static ConstantExpr * from_double( const CodeLocation & loc, double d );
     326        /// generates an array of chars constant of the given string
     327        static ConstantExpr * from_string( const CodeLocation & loc, const std::string & s );
     328        /// generates a null pointer value for the given type. void * if omitted.
     329        static ConstantExpr * null( const CodeLocation & loc, const Type * ptrType = nullptr );
     330
     331        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     332private:
     333        ConstantExpr * clone() const override { return new ConstantExpr{ *this }; }
     334};
     335
     336/// sizeof expression, e.g. `sizeof(int)`, `sizeof 3+4`
     337class SizeofExpr final : public Expr {
     338public:
     339        ptr<Expr> expr;
     340        ptr<Type> type;
     341
     342        SizeofExpr( const CodeLocation & loc, const Expr * e );
     343        SizeofExpr( const CodeLocation & loc, const Type * t );
     344        // deliberately no disambiguating overload for nullptr_t
     345
     346        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     347private:
     348        SizeofExpr * clone() const override { return new SizeofExpr{ *this }; }
     349};
     350
     351/// alignof expression, e.g. `alignof(int)`, `alignof 3+4`
     352class AlignofExpr final : public Expr {
     353public:
     354        ptr<Expr> expr;
     355        ptr<Type> type;
     356
     357        AlignofExpr( const CodeLocation & loc, const Expr * e );
     358        AlignofExpr( const CodeLocation & loc, const Type * t );
     359        // deliberately no disambiguating overload for nullptr_t
     360
     361        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     362private:
     363        AlignofExpr * clone() const override { return new AlignofExpr{ *this }; }
     364};
     365
     366/// offsetof expression before resolver determines field, e.g. `offsetof(MyStruct, myfield)`
     367class UntypedOffsetofExpr final : public Expr {
     368public:
     369        ptr<Type> type;
     370        std::string member;
     371
     372        UntypedOffsetofExpr( const CodeLocation & loc, const Type * ty, const std::string & mem )
     373        : Expr( loc ), type( ty ), member( mem ) {}
     374
     375        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     376private:
     377        UntypedOffsetofExpr * clone() const override { return new UntypedOffsetofExpr{ *this }; }
     378};
     379
     380/// offsetof expression after resolver determines field, e.g. `offsetof(MyStruct, myfield)`
     381class OffsetofExpr final : public Expr {
     382public:
     383        ptr<Type> type;
     384        readonly<DeclWithType> member;
     385
     386        OffsetofExpr( const CodeLocation & loc, const Type * ty, const DeclWithType * mem );
     387
     388        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     389private:
     390        OffsetofExpr * clone() const override { return new OffsetofExpr{ *this }; }
     391};
     392
     393/// a pack of field-offsets for a generic type
     394class OffsetPackExpr final : public Expr {
     395public:
     396        ptr<StructInstType> type;
     397
     398        OffsetPackExpr( const CodeLocation & loc, const StructInstType * ty );
     399
     400        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     401private:
     402        OffsetPackExpr * clone() const override { return new OffsetPackExpr{ *this }; }
     403};
     404
     405/// Variants of short-circuiting logical expression
     406enum LogicalFlag { OrExpr, AndExpr };
     407
     408/// Short-circuiting boolean expression (`&&` or `||`)
     409class LogicalExpr final : public Expr {
     410public:
     411        ptr<Expr> arg1;
     412        ptr<Expr> arg2;
     413        LogicalFlag isAnd;
     414
     415        LogicalExpr( const CodeLocation & loc, const Expr * a1, const Expr * a2, LogicalFlag ia );
     416
     417        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     418private:
     419        LogicalExpr * clone() const override { return new LogicalExpr{ *this }; }
     420};
     421
     422/// Three-argument conditional e.g. `p ? a : b`
     423class ConditionalExpr final : public Expr {
     424public:
     425        ptr<Expr> arg1;
     426        ptr<Expr> arg2;
     427        ptr<Expr> arg3;
     428
     429        ConditionalExpr( const CodeLocation & loc, const Expr * a1, const Expr * a2, const Expr * a3 )
     430        : Expr( loc ), arg1( a1 ), arg2( a2 ), arg3( a3 ) {}
     431
     432        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     433private:
     434        ConditionalExpr * clone() const override { return new ConditionalExpr{ *this }; }
     435};
     436
     437/// Comma expression e.g. `( a , b )`
     438class CommaExpr final : public Expr {
     439public:
     440        ptr<Expr> arg1;
     441        ptr<Expr> arg2;
     442
     443        CommaExpr( const CodeLocation & loc, const Expr * a1, const Expr * a2 )
     444        : Expr( loc ), arg1( a1 ), arg2( a2 ) {}
     445
     446        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     447private:
     448        CommaExpr * clone() const override { return new CommaExpr{ *this }; }
    126449};
    127450
     
    138461};
    139462
     463/// A GCC "asm constraint operand" used in an asm statement, e.g. `[output] "=f" (result)`.
     464/// https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
     465class AsmExpr final : public Expr {
     466public:
     467        ptr<Expr> inout;
     468        ptr<Expr> constraint;
     469};
    140470
    141471//=================================================================================================
     
    146476inline void increment( const class Expr * node, Node::ref_type ref ) { node->increment(ref); }
    147477inline void decrement( const class Expr * node, Node::ref_type ref ) { node->decrement(ref); }
    148 // inline void increment( const class ApplicationExpr * node, Node::ref_type ref ) { node->increment(ref); }
    149 // inline void decrement( const class ApplicationExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    150 // inline void increment( const class UntypedExpr * node, Node::ref_type ref ) { node->increment(ref); }
    151 // inline void decrement( const class UntypedExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    152 // inline void increment( const class NameExpr * node, Node::ref_type ref ) { node->increment(ref); }
    153 // inline void decrement( const class NameExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    154 // inline void increment( const class AddressExpr * node, Node::ref_type ref ) { node->increment(ref); }
    155 // inline void decrement( const class AddressExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    156 // inline void increment( const class LabelAddressExpr * node, Node::ref_type ref ) { node->increment(ref); }
    157 // inline void decrement( const class LabelAddressExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    158 // inline void increment( const class CastExpr * node, Node::ref_type ref ) { node->increment(ref); }
    159 // inline void decrement( const class CastExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    160 // inline void increment( const class KeywordCastExpr * node, Node::ref_type ref ) { node->increment(ref); }
    161 // inline void decrement( const class KeywordCastExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    162 // inline void increment( const class VirtualCastExpr * node, Node::ref_type ref ) { node->increment(ref); }
    163 // inline void decrement( const class VirtualCastExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    164 // inline void increment( const class MemberExpr * node, Node::ref_type ref ) { node->increment(ref); }
    165 // inline void decrement( const class MemberExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    166 // inline void increment( const class UntypedMemberExpr * node, Node::ref_type ref ) { node->increment(ref); }
    167 // inline void decrement( const class UntypedMemberExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    168 // inline void increment( const class VariableExpr * node, Node::ref_type ref ) { node->increment(ref); }
    169 // inline void decrement( const class VariableExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    170 // inline void increment( const class ConstantExpr * node, Node::ref_type ref ) { node->increment(ref); }
    171 // inline void decrement( const class ConstantExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    172 // inline void increment( const class SizeofExpr * node, Node::ref_type ref ) { node->increment(ref); }
    173 // inline void decrement( const class SizeofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    174 // inline void increment( const class AlignofExpr * node, Node::ref_type ref ) { node->increment(ref); }
    175 // inline void decrement( const class AlignofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    176 // inline void increment( const class UntypedOffsetofExpr * node, Node::ref_type ref ) { node->increment(ref); }
    177 // inline void decrement( const class UntypedOffsetofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    178 // inline void increment( const class OffsetofExpr * node, Node::ref_type ref ) { node->increment(ref); }
    179 // inline void decrement( const class OffsetofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    180 // inline void increment( const class OffsetPackExpr * node, Node::ref_type ref ) { node->increment(ref); }
    181 // inline void decrement( const class OffsetPackExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    182 // inline void increment( const class AttrExpr * node, Node::ref_type ref ) { node->increment(ref); }
    183 // inline void decrement( const class AttrExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    184 // inline void increment( const class LogicalExpr * node, Node::ref_type ref ) { node->increment(ref); }
    185 // inline void decrement( const class LogicalExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    186 // inline void increment( const class ConditionalExpr * node, Node::ref_type ref ) { node->increment(ref); }
    187 // inline void decrement( const class ConditionalExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    188 // inline void increment( const class CommaExpr * node, Node::ref_type ref ) { node->increment(ref); }
    189 // inline void decrement( const class CommaExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    190 // inline void increment( const class TypeExpr * node, Node::ref_type ref ) { node->increment(ref); }
    191 // inline void decrement( const class TypeExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    192 // inline void increment( const class AsmExpr * node, Node::ref_type ref ) { node->increment(ref); }
    193 // inline void decrement( const class AsmExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     478inline void increment( const class ApplicationExpr * node, Node::ref_type ref ) { node->increment(ref); }
     479inline void decrement( const class ApplicationExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     480inline void increment( const class UntypedExpr * node, Node::ref_type ref ) { node->increment(ref); }
     481inline void decrement( const class UntypedExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     482inline void increment( const class NameExpr * node, Node::ref_type ref ) { node->increment(ref); }
     483inline void decrement( const class NameExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     484inline void increment( const class AddressExpr * node, Node::ref_type ref ) { node->increment(ref); }
     485inline void decrement( const class AddressExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     486inline void increment( const class LabelAddressExpr * node, Node::ref_type ref ) { node->increment(ref); }
     487inline void decrement( const class LabelAddressExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     488inline void increment( const class CastExpr * node, Node::ref_type ref ) { node->increment(ref); }
     489inline void decrement( const class CastExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     490inline void increment( const class KeywordCastExpr * node, Node::ref_type ref ) { node->increment(ref); }
     491inline void decrement( const class KeywordCastExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     492inline void increment( const class VirtualCastExpr * node, Node::ref_type ref ) { node->increment(ref); }
     493inline void decrement( const class VirtualCastExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     494inline void increment( const class MemberExpr * node, Node::ref_type ref ) { node->increment(ref); }
     495inline void decrement( const class MemberExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     496inline void increment( const class UntypedMemberExpr * node, Node::ref_type ref ) { node->increment(ref); }
     497inline void decrement( const class UntypedMemberExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     498inline void increment( const class VariableExpr * node, Node::ref_type ref ) { node->increment(ref); }
     499inline void decrement( const class VariableExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     500inline void increment( const class ConstantExpr * node, Node::ref_type ref ) { node->increment(ref); }
     501inline void decrement( const class ConstantExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     502inline void increment( const class SizeofExpr * node, Node::ref_type ref ) { node->increment(ref); }
     503inline void decrement( const class SizeofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     504inline void increment( const class AlignofExpr * node, Node::ref_type ref ) { node->increment(ref); }
     505inline void decrement( const class AlignofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     506inline void increment( const class UntypedOffsetofExpr * node, Node::ref_type ref ) { node->increment(ref); }
     507inline void decrement( const class UntypedOffsetofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     508inline void increment( const class OffsetofExpr * node, Node::ref_type ref ) { node->increment(ref); }
     509inline void decrement( const class OffsetofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     510inline void increment( const class OffsetPackExpr * node, Node::ref_type ref ) { node->increment(ref); }
     511inline void decrement( const class OffsetPackExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     512inline void increment( const class LogicalExpr * node, Node::ref_type ref ) { node->increment(ref); }
     513inline void decrement( const class LogicalExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     514inline void increment( const class ConditionalExpr * node, Node::ref_type ref ) { node->increment(ref); }
     515inline void decrement( const class ConditionalExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     516inline void increment( const class CommaExpr * node, Node::ref_type ref ) { node->increment(ref); }
     517inline void decrement( const class CommaExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     518inline void increment( const class TypeExpr * node, Node::ref_type ref ) { node->increment(ref); }
     519inline void decrement( const class TypeExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     520inline void increment( const class AsmExpr * node, Node::ref_type ref ) { node->increment(ref); }
     521inline void decrement( const class AsmExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    194522// inline void increment( const class ImplicitCopyCtorExpr * node, Node::ref_type ref ) { node->increment(ref); }
    195523// inline void decrement( const class ImplicitCopyCtorExpr * node, Node::ref_type ref ) { node->decrement(ref); }
  • src/AST/Fwd.hpp

    r8133121 r1fb7bfd  
    7777class OffsetofExpr;
    7878class OffsetPackExpr;
    79 class AttrExpr;
    8079class LogicalExpr;
    8180class ConditionalExpr;
     
    252251inline void increment( const class OffsetPackExpr *, Node::ref_type );
    253252inline void decrement( const class OffsetPackExpr *, Node::ref_type );
    254 inline void increment( const class AttrExpr *, Node::ref_type );
    255 inline void decrement( const class AttrExpr *, Node::ref_type );
    256253inline void increment( const class LogicalExpr *, Node::ref_type );
    257254inline void decrement( const class LogicalExpr *, Node::ref_type );
  • src/AST/Node.hpp

    r8133121 r1fb7bfd  
    7676// problems and be able to use auto return
    7777template<typename node_t>
    78 auto mutate(const node_t * node) {
     78auto mutate( const node_t * node ) {
    7979        assertf(
    8080                node->strong_count >= 1,
     
    9292}
    9393
    94 std::ostream& operator<< ( std::ostream& out, const Node* node );
     94std::ostream& operator<< ( std::ostream& out, const Node * node );
    9595
    9696/// Base class for the smart pointer types
     
    137137        operator const node_t * () const { return node; }
    138138
     139        /// wrapper for convenient access to dynamic_cast
    139140        template<typename o_node_t>
    140141        const o_node_t * as() const { return dynamic_cast<const o_node_t *>(node); }
     142
     143        /// Sets this pointer to a mutated version of a pointer (possibly) owned elsehere.
     144        /// Returns a mutable version of the pointer in this node.
     145        node_t * set_and_mutate( const node_t * n ) {
     146                // ensure ownership of `n` by this node to avoid spurious single-owner mutates
     147                assign( n );
     148                // get mutable version of `n`
     149                auto r = mutate( node );
     150                // re-assign mutable version in case `mutate()` produced a new pointer
     151                assign( r );
     152                return r;
     153        }
    141154
    142155        using ptr = const node_t *;
  • src/AST/Type.hpp

    r8133121 r1fb7bfd  
    3232
    3333class Type : public Node {
    34         CV::Qualifiers tq;
    35 public:
    36         Type( CV::Qualifiers q = {} ) : tq(q) {}
    37 
    38         CV::Qualifiers qualifiers() const { return tq; }
    39         bool is_const() const { return tq.is_const; }
    40         bool is_volatile() const { return tq.is_volatile; }
    41         bool is_restrict() const { return tq.is_restrict; }
    42         bool is_lvalue() const { return tq.is_lvalue; }
    43         bool is_mutex() const { return tq.is_mutex; }
    44         bool is_atomic() const { return tq.is_atomic; }
    45 
    46         void set_qualifiers( CV::Qualifiers q ) { tq = q; }
    47         void set_const( bool v ) { tq.is_const = v; }
    48         void set_restrict( bool v ) { tq.is_restrict = v; }
    49         void set_lvalue( bool v ) { tq.is_lvalue = v; }
    50         void set_mutex( bool v ) { tq.is_mutex = v; }
    51         void set_atomic( bool v ) { tq.is_atomic = v; }
     34public:
     35        CV::Qualifiers qualifiers;
     36       
     37        Type( CV::Qualifiers q = {} ) : qualifiers(q) {}
     38
     39        bool is_const() const { return qualifiers.is_const; }
     40        bool is_volatile() const { return qualifiers.is_volatile; }
     41        bool is_restrict() const { return qualifiers.is_restrict; }
     42        bool is_lvalue() const { return qualifiers.is_lvalue; }
     43        bool is_mutex() const { return qualifiers.is_mutex; }
     44        bool is_atomic() const { return qualifiers.is_atomic; }
     45
     46        void set_const( bool v ) { qualifiers.is_const = v; }
     47        void set_restrict( bool v ) { qualifiers.is_restrict = v; }
     48        void set_lvalue( bool v ) { qualifiers.is_lvalue = v; }
     49        void set_mutex( bool v ) { qualifiers.is_mutex = v; }
     50        void set_atomic( bool v ) { qualifiers.is_atomic = v; }
    5251
    5352        /// How many elemental types are represented by this type
     
    254253class FunctionType final : public ParameterizedType {
    255254public:
    256         std::vector<ptr<DeclWithType>> returnVals;
    257         std::vector<ptr<DeclWithType>> parameters;
     255        std::vector<ptr<DeclWithType>> returns;
     256        std::vector<ptr<DeclWithType>> params;
    258257
    259258        /// Does the function accept a variable number of arguments following the arguments specified
     
    265264
    266265        FunctionType( ArgumentFlag va = FixedArgs, CV::Qualifiers q = {} )
    267         : ParameterizedType(q), returnVals(), parameters(), isVarArgs(va) {}
     266        : ParameterizedType(q), returns(), params(), isVarArgs(va) {}
    268267
    269268        /// true if either the parameters or return values contain a tttype
    270269        bool isTtype() const;
    271270        /// true if function parameters are unconstrained by prototype
    272         bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
     271        bool isUnprototyped() const { return isVarArgs && params.size() == 0; }
    273272
    274273        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
     
    280279class ReferenceToType : public ParameterizedType {
    281280public:
    282         std::vector<ptr<Expr>> parameters;
     281        std::vector<ptr<Expr>> params;
    283282        std::vector<ptr<Attribute>> attributes;
    284283        std::string name;
     
    287286        ReferenceToType( const std::string& n, CV::Qualifiers q = {},
    288287                std::vector<ptr<Attribute>> && as = {} )
    289         : ParameterizedType(q), parameters(), attributes(std::move(as)), name(n) {}
     288        : ParameterizedType(q), params(), attributes(std::move(as)), name(n) {}
    290289
    291290        /// Gets aggregate declaration this type refers to
  • src/AST/Visitor.hpp

    r8133121 r1fb7bfd  
    6969    virtual const ast::Expr *             visit( const ast::OffsetofExpr         * ) = 0;
    7070    virtual const ast::Expr *             visit( const ast::OffsetPackExpr       * ) = 0;
    71     virtual const ast::Expr *             visit( const ast::AttrExpr             * ) = 0;
    7271    virtual const ast::Expr *             visit( const ast::LogicalExpr          * ) = 0;
    7372    virtual const ast::Expr *             visit( const ast::ConditionalExpr      * ) = 0;
  • src/AST/porting.md

    r8133121 r1fb7bfd  
    66  * specialization: strong pointer `ast::ptr<T>` is used for an ownership relationship
    77  * specialization: weak pointer `ast::readonly<T>` is used for an observation relationship
    8   * added `ast::ptr_base<T,R>::as<S>()` with same semantics as `dynamic_cast<S*>(p)`
     8* added `ast::ptr_base<T,R>::as<S>()` with same semantics as `dynamic_cast<S*>(p)`
     9* added `N * ast::ptr_base<N,R>::set_and_mutate( const N * n )`
     10  * takes ownership of `n`, then returns a mutable version owned by this pointer
     11  * Some debate on whether this is a good approach:
     12    * makes an easy path to cloning, which we were trying to eliminate
     13      * counter-point: these are all mutating clones rather than lifetime-preserving clones, and thus "necessary" (for some definition)
     14    * existing uses:
     15      * `VariableExpr::VariableExpr`, `UntypedExpr::createDeref`
     16        * both involve grabbing a type from elsewhere and making an `lvalue` copy of it
     17        * could potentially be replaced by a view class something like this:
     18          ```
     19          template<unsigned Quals>
     20          class AddQualifiersType final : public Type {
     21            readonly<Type> base;
     22            // ...
     23          };
     24          ```
     25          * requires all `qualifiers` use (and related helpers) to be virtual, non-zero overhead
     26          * also subtle semantic change, where mutations to the source decl now change the viewing expression
    927
    1028## Visitors ##
     
    106124  * allows `newObject` as just default settings
    107125
     126`NamedTypeDecl`
     127* `parameters` => `params`
     128
    108129`TypeDecl`
    109130* moved `TypeDecl::Kind` to `ast::TypeVar::Kind`
     131
     132`AggregateDecl`
     133* `parameters` => `params`
    110134
    111135`EnumDecl`
     
    115139* Merged `inferParams`/`resnSlots` into union, as suggested by comment in old version
    116140  * does imply get_/set_ API, and some care about moving backward
     141* added constructor that sets result, for benefit of types that set it directly
     142
     143`ApplicationExpr`
     144* `function` => `func`
     145
     146`UntypedExpr`
     147* `function` => `func`
     148* removed `begin_args()` in favour of `args.begin()`
     149
     150`MemberExpr`
     151* **TODO** port setup of `result` in constructor
     152
     153`ConstantExpr`
     154* inlined features of `Constant`, never used elsewhere, so removed `Constant`
     155  * `Constant Constant::from_int(int)` etc. => `ConstantExpr * ConstantExpr::from_int(CodeLocation, int)`
     156    * allocates new `ConstantExpr`, consistent with all existing uses
     157
     158`SizeofExpr`, `AlignofExpr`
     159* `isType` deprecated in favour of boolean check on `type`
     160  * all existing uses assume `type` set if true and don't use `expr`
     161
     162`AttrExpr`
     163* did not port due to feature deprecation (e.g. `expr@attribute`)
     164
     165`LogicalExpr`
     166* un-defaulted constructor parameter determining `&&` or `||`
    117167
    118168`Init`
     
    148198`Type`
    149199* `CV::Qualifiers` moved to end of constructor parameter list, defaulted to `{}`
     200  * removed getter, setter in favour of public `qualifiers` field
    150201  * `ReferenceToType` puts a defaulted list of attributes after qualifiers
    151202* `forall` field split off into `ParameterizedType` subclass
     
    160211  * `getAggr()` => `aggr()`
    161212    * also now returns `const AggregateDecl *`
    162 * `genericSubstitution()` moved to own visitor **TODO** write
     213* `genericSubstitution()` moved to own visitor in `AST/GenericSubstitution.hpp` **TODO** write
    163214
    164215`BasicType`
     
    167218`ReferenceToType`
    168219* deleted `get_baseParameters()` from children
    169   * replace with `aggr() ? aggr()->parameters : nullptr`
     220  * replace with `aggr() ? aggr()->params : nullptr`
     221* `parameters` => `params`
    170222* hoisted `lookup` implementation into parent, made non-virtual
    171223  * also changed to return vector rather than filling; change back if any great win for reuse
     
    178230
    179231`FunctionType`
     232* `returnVals` => `returns`
     233* `parameters` => `params`
    180234* `bool isVarArgs;` => `enum ArgumentFlag { FixedArgs, VariableArgs }; ArgumentFlag isVarArgs;`
    181235
  • src/ResolvExpr/Unify.cc

    r8133121 r1fb7bfd  
    2121#include <string>                 // for string, operator==, operator!=, bas...
    2222#include <utility>                // for pair, move
    23 
     23#include <vector>
     24
     25#include "AST/Node.hpp"
     26#include "AST/Type.hpp"
    2427#include "Common/PassVisitor.h"   // for PassVisitor
    2528#include "FindOpenVars.h"         // for findOpenVars
     
    630633        }
    631634
    632         // xxx - compute once and store in the FunctionType?
    633635        Type * extractResultType( FunctionType * function ) {
    634636                if ( function->get_returnVals().size() == 0 ) {
     
    644646                }
    645647        }
     648
     649        ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func ) {
     650                assert(!"restore after AST added to build");
     651                // if ( func->returns.empty() ) return new ast::VoidType{};
     652                // if ( func->returns.size() == 1 ) return func->returns[0]->get_type();
     653
     654                // std::vector<ast::ptr<ast::Type>> tys;
     655                // for ( const ast::DeclWithType * decl : func->returns ) {
     656                //      tys.emplace_back( decl->get_type() );
     657                // }
     658                // return new ast::TupleType{ std::move(tys) };
     659        }
    646660} // namespace ResolvExpr
    647661
  • src/ResolvExpr/typeops.h

    r8133121 r1fb7bfd  
    1818#include <vector>
    1919
     20#include "AST/Node.hpp"
     21#include "AST/Type.hpp"
    2022#include "SynTree/SynTree.h"
    2123#include "SynTree/Type.h"
     
    99101        /// creates the type represented by the list of returnVals in a FunctionType. The caller owns the return value.
    100102        Type * extractResultType( FunctionType * functionType );
     103        /// Creates or extracts the type represented by the list of returns in a `FunctionType`.
     104        ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func );
    101105
    102106        // in CommonType.cc
Note: See TracChangeset for help on using the changeset viewer.