Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/SynTree/Expression.h

    r849720f rd807ca28  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Thr Aug 15 13:46:00 2019
    13 // Update Count     : 54
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun Sep  3 19:23:46 2017
     13// Update Count     : 48
    1414//
    1515
    … …  
    2121#include <memory>                 // for allocator, unique_ptr
    2222#include <string>                 // for string
    23 #include <vector>                 // for vector
    2423
    2524#include "BaseSyntaxNode.h"       // for BaseSyntaxNode
    … …  
    3938/// but subject to decay-to-pointer and type parameter renaming
    4039struct ParamEntry {
    41         ParamEntry(): decl( 0 ), declptr( nullptr ), actualType( nullptr ), formalType( nullptr ), expr( nullptr ) {}
    42         ParamEntry( UniqueId decl, Declaration * declptr, Type * actualType, Type * formalType, Expression* expr );
     40        ParamEntry(): decl( 0 ), actualType( 0 ), formalType( 0 ), expr( 0 ), inferParams( new InferredParams ) {}
     41        ParamEntry( UniqueId decl, Type * actualType, Type * formalType, Expression* expr ): decl( decl ), actualType( actualType ), formalType( formalType ), expr( expr ), inferParams( new InferredParams ) {}
    4342        ParamEntry( const ParamEntry & other );
    4443        ParamEntry( ParamEntry && other );
    4544        ~ParamEntry();
     45        ParamEntry & operator=( const ParamEntry & other );
    4646        ParamEntry & operator=( ParamEntry && other );
    4747
    48         UniqueId const decl;
    49         Declaration * const declptr;
    50         Type * const actualType;
    51         Type * const formalType;
     48        UniqueId decl;
     49        Type * actualType;
     50        Type * formalType;
    5251        Expression * expr;
     52        std::unique_ptr< InferredParams > inferParams;
    5353};
    5454
    … …  
    5959        TypeSubstitution * env;
    6060        bool extension = false;
    61         InferredParams inferParams;       ///< Post-resolution inferred parameter slots
    62         std::vector<UniqueId> resnSlots;  ///< Pre-resolution inferred parameter slots
    63 
    64         // xxx - should turn inferParams+resnSlots into a union to save some memory
     61        InferredParams inferParams;
    6562
    6663        Expression();
    … …  
    7168        const Type * get_result() const { return result; }
    7269        void set_result( Type * newValue ) { result = newValue; }
    73         virtual bool get_lvalue() const;
    7470
    7571        TypeSubstitution * get_env() const { return env; }
    … …  
    7874        Expression * set_extension( bool exten ) { extension = exten; return this; }
    7975
     76        InferredParams & get_inferParams() { return inferParams; }
     77
    8078        // move other's inferParams to this
    8179        void spliceInferParams( Expression * other );
    … …  
    8381        virtual Expression * clone() const override = 0;
    8482        virtual void accept( Visitor & v ) override = 0;
    85         virtual void accept( Visitor & v ) const override = 0;
    8683        virtual Expression * acceptMutator( Mutator & m ) override = 0;
    8784        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    9996        virtual ~ApplicationExpr();
    10097
    101         bool get_lvalue() const final;
    102 
    10398        Expression * get_function() const { return function; }
    10499        void set_function( Expression * newValue ) { function = newValue; }
    105100        std::list<Expression *>& get_args() { return args; }
    106101
    107         virtual ApplicationExpr * clone() const override { return new ApplicationExpr( * this ); }
    108         virtual void accept( Visitor & v ) override { v.visit( this ); }
    109         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    110         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    111         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     102        virtual ApplicationExpr * clone() const { return new ApplicationExpr( * this ); }
     103        virtual void accept( Visitor & v ) { v.visit( this ); }
     104        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     105        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    112106};
    113107
    … …  
    124118        virtual ~UntypedExpr();
    125119
    126         bool get_lvalue() const final;
    127 
    128120        Expression * get_function() const { return function; }
    129121        void set_function( Expression * newValue ) { function = newValue; }
    … …  
    136128        static UntypedExpr * createAssign( Expression * arg1, Expression * arg2 );
    137129
    138         virtual UntypedExpr * clone() const override { return new UntypedExpr( * this ); }
    139         virtual void accept( Visitor & v ) override { v.visit( this ); }
    140         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    141         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    142         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     130        virtual UntypedExpr * clone() const { return new UntypedExpr( * this ); }
     131        virtual void accept( Visitor & v ) { v.visit( this ); }
     132        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     133        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    143134};
    144135
    … …  
    155146        void set_name( std::string newValue ) { name = newValue; }
    156147
    157         virtual NameExpr * clone() const override { return new NameExpr( * this ); }
    158         virtual void accept( Visitor & v ) override { v.visit( this ); }
    159         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    160         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    161         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     148        virtual NameExpr * clone() const { return new NameExpr( * this ); }
     149        virtual void accept( Visitor & v ) { v.visit( this ); }
     150        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     151        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    162152};
    163153
    … …  
    177167        void set_arg(Expression * newValue ) { arg = newValue; }
    178168
    179         virtual AddressExpr * clone() const override { return new AddressExpr( * this ); }
    180         virtual void accept( Visitor & v ) override { v.visit( this ); }
    181         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    182         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    183         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     169        virtual AddressExpr * clone() const { return new AddressExpr( * this ); }
     170        virtual void accept( Visitor & v ) { v.visit( this ); }
     171        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     172        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    184173};
    185174
    … …  
    194183        virtual ~LabelAddressExpr();
    195184
    196         virtual LabelAddressExpr * clone() const override { return new LabelAddressExpr( * this ); }
    197         virtual void accept( Visitor & v ) override { v.visit( this ); }
    198         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    199         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    200         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     185        virtual LabelAddressExpr * clone() const { return new LabelAddressExpr( * this ); }
     186        virtual void accept( Visitor & v ) { v.visit( this ); }
     187        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     188        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    201189};
    202190
    … …  
    205193  public:
    206194        Expression * arg;
    207         bool isGenerated = true; // cast generated implicitly by code generation or explicit in program
     195        bool isGenerated = true; // whether this cast appeared in the source program
    208196
    209197        CastExpr( Expression * arg, bool isGenerated = true );
    … …  
    213201        virtual ~CastExpr();
    214202
    215         bool get_lvalue() const final;
    216 
    217203        Expression * get_arg() const { return arg; }
    218204        void set_arg( Expression * newValue ) { arg = newValue; }
    219205
    220         virtual CastExpr * clone() const override { return new CastExpr( * this ); }
    221         virtual void accept( Visitor & v ) override { v.visit( this ); }
    222         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    223         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    224         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     206        virtual CastExpr * clone() const { return new CastExpr( * this ); }
     207        virtual void accept( Visitor & v ) { v.visit( this ); }
     208        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     209        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    225210};
    226211
    … …  
    239224        const std::string & targetString() const;
    240225
    241         virtual KeywordCastExpr * clone() const override { return new KeywordCastExpr( * this ); }
    242         virtual void accept( Visitor & v ) override { v.visit( this ); }
    243         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    244         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    245         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     226        virtual KeywordCastExpr * clone() const { return new KeywordCastExpr( * this ); }
     227        virtual void accept( Visitor & v ) { v.visit( this ); }
     228        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     229        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    246230};
    247231
    … …  
    258242        void set_arg( Expression * newValue ) { arg = newValue; }
    259243
    260         virtual VirtualCastExpr * clone() const override { return new VirtualCastExpr( * this ); }
    261         virtual void accept( Visitor & v ) override { v.visit( this ); }
    262         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    263         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    264         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     244        virtual VirtualCastExpr * clone() const { return new VirtualCastExpr( * this ); }
     245        virtual void accept( Visitor & v ) { v.visit( this ); }
     246        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     247        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    265248};
    266249
    … …  
    274257        UntypedMemberExpr( const UntypedMemberExpr & other );
    275258        virtual ~UntypedMemberExpr();
    276 
    277         bool get_lvalue() const final;
    278259
    279260        Expression * get_member() const { return member; }
    … …  
    282263        void set_aggregate( Expression * newValue ) { aggregate = newValue; }
    283264
    284         virtual UntypedMemberExpr * clone() const override { return new UntypedMemberExpr( * this ); }
    285         virtual void accept( Visitor & v ) override { v.visit( this ); }
    286         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    287         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    288         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     265        virtual UntypedMemberExpr * clone() const { return new UntypedMemberExpr( * this ); }
     266        virtual void accept( Visitor & v ) { v.visit( this ); }
     267        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     268        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    289269};
    290270
    … …  
    299279        MemberExpr( const MemberExpr & other );
    300280        virtual ~MemberExpr();
    301 
    302         bool get_lvalue() const final;
    303281
    304282        DeclarationWithType * get_member() const { return member; }
    … …  
    307285        void set_aggregate( Expression * newValue ) { aggregate = newValue; }
    308286
    309         virtual MemberExpr * clone() const override { return new MemberExpr( * this ); }
    310         virtual void accept( Visitor & v ) override { v.visit( this ); }
    311         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    312         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    313         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     287        virtual MemberExpr * clone() const { return new MemberExpr( * this ); }
     288        virtual void accept( Visitor & v ) { v.visit( this ); }
     289        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     290        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    314291};
    315292
    … …  
    320297        DeclarationWithType * var;
    321298
    322         VariableExpr();
    323299        VariableExpr( DeclarationWithType * var );
    324300        VariableExpr( const VariableExpr & other );
    325301        virtual ~VariableExpr();
    326302
    327         bool get_lvalue() const final;
    328 
    329303        DeclarationWithType * get_var() const { return var; }
    330304        void set_var( DeclarationWithType * newValue ) { var = newValue; }
    … …  
    332306        static VariableExpr * functionPointer( FunctionDecl * decl );
    333307
    334         virtual VariableExpr * clone() const override { return new VariableExpr( * this ); }
    335         virtual void accept( Visitor & v ) override { v.visit( this ); }
    336         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    337         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    338         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     308        virtual VariableExpr * clone() const { return new VariableExpr( * this ); }
     309        virtual void accept( Visitor & v ) { v.visit( this ); }
     310        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     311        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    339312};
    340313
    … …  
    354327        long long int intValue() const;
    355328
    356         virtual ConstantExpr * clone() const override { return new ConstantExpr( * this ); }
    357         virtual void accept( Visitor & v ) override { v.visit( this ); }
    358         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    359         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    360         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     329        virtual ConstantExpr * clone() const { return new ConstantExpr( * this ); }
     330        virtual void accept( Visitor & v ) { v.visit( this ); }
     331        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     332        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    361333};
    362334
    … …  
    380352        void set_isType( bool newValue ) { isType = newValue; }
    381353
    382         virtual SizeofExpr * clone() const override { return new SizeofExpr( * this ); }
    383         virtual void accept( Visitor & v ) override { v.visit( this ); }
    384         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    385         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    386         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     354        virtual SizeofExpr * clone() const { return new SizeofExpr( * this ); }
     355        virtual void accept( Visitor & v ) { v.visit( this ); }
     356        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     357        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    387358};
    388359
    … …  
    406377        void set_isType( bool newValue ) { isType = newValue; }
    407378
    408         virtual AlignofExpr * clone() const override { return new AlignofExpr( * this ); }
    409         virtual void accept( Visitor & v ) override { v.visit( this ); }
    410         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    411         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    412         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     379        virtual AlignofExpr * clone() const { return new AlignofExpr( * this ); }
     380        virtual void accept( Visitor & v ) { v.visit( this ); }
     381        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     382        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    413383};
    414384
    … …  
    428398        void set_type( Type * newValue ) { type = newValue; }
    429399
    430         virtual UntypedOffsetofExpr * clone() const override { return new UntypedOffsetofExpr( * this ); }
    431         virtual void accept( Visitor & v ) override { v.visit( this ); }
    432         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    433         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    434         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     400        virtual UntypedOffsetofExpr * clone() const { return new UntypedOffsetofExpr( * this ); }
     401        virtual void accept( Visitor & v ) { v.visit( this ); }
     402        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     403        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    435404};
    436405
    … …  
    450419        void set_member( DeclarationWithType * newValue ) { member = newValue; }
    451420
    452         virtual OffsetofExpr * clone() const override { return new OffsetofExpr( * this ); }
    453         virtual void accept( Visitor & v ) override { v.visit( this ); }
    454         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    455         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    456         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     421        virtual OffsetofExpr * clone() const { return new OffsetofExpr( * this ); }
     422        virtual void accept( Visitor & v ) { v.visit( this ); }
     423        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     424        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    457425};
    458426
    … …  
    469437        void set_type( StructInstType * newValue ) { type = newValue; }
    470438
    471         virtual OffsetPackExpr * clone() const override { return new OffsetPackExpr( * this ); }
    472         virtual void accept( Visitor & v ) override { v.visit( this ); }
    473         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    474         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    475         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     439        virtual OffsetPackExpr * clone() const { return new OffsetPackExpr( * this ); }
     440        virtual void accept( Visitor & v ) { v.visit( this ); }
     441        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     442        virtual void print( std::ostream & os, Indenter indent = {} ) const;
     443};
     444
     445/// AttrExpr represents an @attribute expression (like sizeof, but user-defined)
     446class AttrExpr : public Expression {
     447  public:
     448        Expression * attr;
     449        Expression * expr;
     450        Type * type;
     451        bool isType;
     452
     453        AttrExpr(Expression * attr, Expression * expr );
     454        AttrExpr( const AttrExpr & other );
     455        AttrExpr( Expression * attr, Type * type );
     456        virtual ~AttrExpr();
     457
     458        Expression * get_attr() const { return attr; }
     459        void set_attr( Expression * newValue ) { attr = newValue; }
     460        Expression * get_expr() const { return expr; }
     461        void set_expr( Expression * newValue ) { expr = newValue; }
     462        Type * get_type() const { return type; }
     463        void set_type( Type * newValue ) { type = newValue; }
     464        bool get_isType() const { return isType; }
     465        void set_isType( bool newValue ) { isType = newValue; }
     466
     467        virtual AttrExpr * clone() const { return new AttrExpr( * this ); }
     468        virtual void accept( Visitor & v ) { v.visit( this ); }
     469        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     470        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    476471};
    477472
    … …  
    492487        void set_arg2( Expression * newValue ) { arg2 = newValue; }
    493488
    494         virtual LogicalExpr * clone() const override { return new LogicalExpr( * this ); }
    495         virtual void accept( Visitor & v ) override { v.visit( this ); }
    496         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    497         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    498         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     489        virtual LogicalExpr * clone() const { return new LogicalExpr( * this ); }
     490        virtual void accept( Visitor & v ) { v.visit( this ); }
     491        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     492        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    499493
    500494  private:
    … …  
    512506        ConditionalExpr( const ConditionalExpr & other );
    513507        virtual ~ConditionalExpr();
    514 
    515         bool get_lvalue() const final;
    516508
    517509        Expression * get_arg1() const { return arg1; }
    … …  
    522514        void set_arg3( Expression * newValue ) { arg3 = newValue; }
    523515
    524         virtual ConditionalExpr * clone() const override { return new ConditionalExpr( * this ); }
    525         virtual void accept( Visitor & v ) override { v.visit( this ); }
    526         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    527         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    528         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     516        virtual ConditionalExpr * clone() const { return new ConditionalExpr( * this ); }
     517        virtual void accept( Visitor & v ) { v.visit( this ); }
     518        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     519        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    529520};
    530521
    … …  
    538529        CommaExpr( const CommaExpr & other );
    539530        virtual ~CommaExpr();
    540 
    541         bool get_lvalue() const final;
    542531
    543532        Expression * get_arg1() const { return arg1; }
    … …  
    546535        void set_arg2( Expression * newValue ) { arg2 = newValue; }
    547536
    548         virtual CommaExpr * clone() const override { return new CommaExpr( * this ); }
    549         virtual void accept( Visitor & v ) override { v.visit( this ); }
    550         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    551         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    552         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     537        virtual CommaExpr * clone() const { return new CommaExpr( * this ); }
     538        virtual void accept( Visitor & v ) { v.visit( this ); }
     539        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     540        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    553541};
    554542
    … …  
    565553        void set_type( Type * newValue ) { type = newValue; }
    566554
    567         virtual TypeExpr * clone() const override { return new TypeExpr( * this ); }
    568         virtual void accept( Visitor & v ) override { v.visit( this ); }
    569         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    570         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    571         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     555        virtual TypeExpr * clone() const { return new TypeExpr( * this ); }
     556        virtual void accept( Visitor & v ) { v.visit( this ); }
     557        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     558        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    572559};
    573560
    … …  
    592579        void set_operand( Expression * newValue ) { operand = newValue; }
    593580
    594         virtual AsmExpr * clone() const override { return new AsmExpr( * this ); }
    595         virtual void accept( Visitor & v ) override { v.visit( this ); }
    596         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    597         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    598         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     581        virtual AsmExpr * clone() const { return new AsmExpr( * this ); }
     582        virtual void accept( Visitor & v ) { v.visit( this ); }
     583        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     584        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    599585
    600586        // https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
    … …  
    605591class ImplicitCopyCtorExpr : public Expression {
    606592public:
    607         ApplicationExpr * callExpr = nullptr;
     593        ApplicationExpr * callExpr;
     594        std::list< ObjectDecl * > tempDecls;
     595        std::list< ObjectDecl * > returnDecls;
     596        std::list< Expression * > dtors;
    608597
    609598        ImplicitCopyCtorExpr( ApplicationExpr * callExpr );
    … …  
    611600        virtual ~ImplicitCopyCtorExpr();
    612601
    613         virtual ImplicitCopyCtorExpr * clone() const override { return new ImplicitCopyCtorExpr( * this ); }
    614         virtual void accept( Visitor & v ) override { v.visit( this ); }
    615         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    616         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    617         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     602        ApplicationExpr * get_callExpr() const { return callExpr; }
     603        void set_callExpr( ApplicationExpr * newValue ) { callExpr = newValue; }
     604
     605        std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
     606        std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
     607        std::list< Expression * > & get_dtors() { return dtors; }
     608
     609        virtual ImplicitCopyCtorExpr * clone() const { return new ImplicitCopyCtorExpr( * this ); }
     610        virtual void accept( Visitor & v ) { v.visit( this ); }
     611        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     612        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    618613};
    619614
    … …  
    627622        ~ConstructorExpr();
    628623
    629         bool get_lvalue() const final;
    630 
    631624        Expression * get_callExpr() const { return callExpr; }
    632625        void set_callExpr( Expression * newValue ) { callExpr = newValue; }
    633626
    634         virtual ConstructorExpr * clone() const override { return new ConstructorExpr( * this ); }
    635         virtual void accept( Visitor & v ) override { v.visit( this ); }
    636         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    637         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    638         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     627        virtual ConstructorExpr * clone() const { return new ConstructorExpr( * this ); }
     628        virtual void accept( Visitor & v ) { v.visit( this ); }
     629        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     630        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    639631};
    640632
    … …  
    648640        virtual ~CompoundLiteralExpr();
    649641
    650         bool get_lvalue() const final;
    651 
    652642        Initializer * get_initializer() const { return initializer; }
    653643        void set_initializer( Initializer * i ) { initializer = i; }
    654644
    655         virtual CompoundLiteralExpr * clone() const override { return new CompoundLiteralExpr( * this ); }
    656         virtual void accept( Visitor & v ) override { v.visit( this ); }
    657         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    658         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    659         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     645        virtual CompoundLiteralExpr * clone() const { return new CompoundLiteralExpr( * this ); }
     646        virtual void accept( Visitor & v ) { v.visit( this ); }
     647        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     648        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    660649};
    661650
    … …  
    673662        RangeExpr * set_high( Expression * high ) { RangeExpr::high = high; return this; }
    674663
    675         virtual RangeExpr * clone() const override { return new RangeExpr( * this ); }
    676         virtual void accept( Visitor & v ) override { v.visit( this ); }
    677         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    678         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    679         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     664        virtual RangeExpr * clone() const { return new RangeExpr( * this ); }
     665        virtual void accept( Visitor & v ) { v.visit( this ); }
     666        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     667        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    680668};
    681669
    … …  
    691679        std::list<Expression*>& get_exprs() { return exprs; }
    692680
    693         virtual UntypedTupleExpr * clone() const override { return new UntypedTupleExpr( * this ); }
    694         virtual void accept( Visitor & v ) override { v.visit( this ); }
    695         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    696         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    697         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     681        virtual UntypedTupleExpr * clone() const { return new UntypedTupleExpr( * this ); }
     682        virtual void accept( Visitor & v ) { v.visit( this ); }
     683        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     684        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    698685};
    699686
    … …  
    707694        virtual ~TupleExpr();
    708695
    709         bool get_lvalue() const final;
    710 
    711696        std::list<Expression*>& get_exprs() { return exprs; }
    712697
    713         virtual TupleExpr * clone() const override { return new TupleExpr( * this ); }
    714         virtual void accept( Visitor & v ) override { v.visit( this ); }
    715         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    716         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    717         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     698        virtual TupleExpr * clone() const { return new TupleExpr( * this ); }
     699        virtual void accept( Visitor & v ) { v.visit( this ); }
     700        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     701        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    718702};
    719703
    … …  
    727711        TupleIndexExpr( const TupleIndexExpr & other );
    728712        virtual ~TupleIndexExpr();
    729 
    730         bool get_lvalue() const final;
    731713
    732714        Expression * get_tuple() const { return tuple; }
    … …  
    735717        TupleIndexExpr * set_index( unsigned int newValue ) { index = newValue; return this; }
    736718
    737         virtual TupleIndexExpr * clone() const override { return new TupleIndexExpr( * this ); }
    738         virtual void accept( Visitor & v ) override { v.visit( this ); }
    739         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    740         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    741         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     719        virtual TupleIndexExpr * clone() const { return new TupleIndexExpr( * this ); }
     720        virtual void accept( Visitor & v ) { v.visit( this ); }
     721        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     722        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    742723};
    743724
    … …  
    754735        StmtExpr * get_stmtExpr() const { return stmtExpr; }
    755736
    756         virtual TupleAssignExpr * clone() const override { return new TupleAssignExpr( * this ); }
    757         virtual void accept( Visitor & v ) override { v.visit( this ); }
    758         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    759         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    760         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    761 
    762         friend class ConverterNewToOld;
    763   private:
    764     TupleAssignExpr( StmtExpr * stmts );
     737        virtual TupleAssignExpr * clone() const { return new TupleAssignExpr( * this ); }
     738        virtual void accept( Visitor & v ) { v.visit( this ); }
     739        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     740        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    765741};
    766742
    … …  
    772748        std::list< Expression * > dtors; // destructor(s) for return variable(s)
    773749
    774         // readonly
    775         ExprStmt * resultExpr = nullptr;
    776 
    777750        StmtExpr( CompoundStmt * statements );
    778751        StmtExpr( const StmtExpr & other );
    779752        virtual ~StmtExpr();
    780753
    781         bool get_lvalue() const final;
    782 
    783754        CompoundStmt * get_statements() const { return statements; }
    784755        StmtExpr * set_statements( CompoundStmt * newValue ) { statements = newValue; return this; }
    … …  
    790761        std::list< Expression * > & get_dtors() { return dtors; }
    791762
    792         virtual StmtExpr * clone() const override { return new StmtExpr( * this ); }
    793         virtual void accept( Visitor & v ) override { v.visit( this ); }
    794         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    795         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    796         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     763        virtual StmtExpr * clone() const { return new StmtExpr( * this ); }
     764        virtual void accept( Visitor & v ) { v.visit( this ); }
     765        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     766        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    797767};
    798768
    … …  
    818788        int get_id() const { return id; }
    819789
    820         virtual UniqueExpr * clone() const override { return new UniqueExpr( * this ); }
    821         virtual void accept( Visitor & v ) override { v.visit( this ); }
    822         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    823         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    824         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     790        virtual UniqueExpr * clone() const { return new UniqueExpr( * this ); }
     791        virtual void accept( Visitor & v ) { v.visit( this ); }
     792        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     793        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    825794
    826795private:
    … …  
    853822        std::list<InitAlternative> & get_initAlts() { return initAlts; }
    854823
    855         virtual UntypedInitExpr * clone() const override { return new UntypedInitExpr( * this ); }
    856         virtual void accept( Visitor & v ) override { v.visit( this ); }
    857         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    858         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    859         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     824        virtual UntypedInitExpr * clone() const { return new UntypedInitExpr( * this ); }
     825        virtual void accept( Visitor & v ) { v.visit( this ); }
     826        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     827        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    860828};
    861829
    … …  
    875843        InitExpr * set_designation( Designation * newValue ) { designation = newValue; return this; }
    876844
    877         virtual InitExpr * clone() const override { return new InitExpr( * this ); }
    878         virtual void accept( Visitor & v ) override { v.visit( this ); }
    879         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    880         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    881         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     845        virtual InitExpr * clone() const { return new InitExpr( * this ); }
     846        virtual void accept( Visitor & v ) { v.visit( this ); }
     847        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     848        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    882849};
    883850
    … …  
    886853public:
    887854        Expression * expr;
    888         Declaration * deleteStmt;
    889 
    890         DeletedExpr( Expression * expr, Declaration * deleteStmt );
     855        BaseSyntaxNode * deleteStmt;
     856
     857        DeletedExpr( Expression * expr, BaseSyntaxNode * deleteStmt );
    891858        DeletedExpr( const DeletedExpr & other );
    892859        ~DeletedExpr();
    893860
    894         virtual DeletedExpr * clone() const override { return new DeletedExpr( * this ); }
    895         virtual void accept( Visitor & v ) override { v.visit( this ); }
    896         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    897         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    898         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    899 };
    900 
    901 /// expression wrapping the use of a default argument - should never make it past the resolver.
    902 class DefaultArgExpr : public Expression {
    903 public:
    904         Expression * expr;
    905 
    906         DefaultArgExpr( Expression * expr );
    907         DefaultArgExpr( const DefaultArgExpr & other );
    908         ~DefaultArgExpr();
    909 
    910         virtual DefaultArgExpr * clone() const override { return new DefaultArgExpr( * this ); }
    911         virtual void accept( Visitor & v ) override { v.visit( this ); }
    912         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    913         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    914         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     861        virtual DeletedExpr * clone() const { return new DeletedExpr( * this ); }
     862        virtual void accept( Visitor & v ) { v.visit( this ); }
     863        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     864        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    915865};
    916866
    … …  
    937887        virtual ~GenericExpr();
    938888
    939         virtual GenericExpr * clone() const override { return new GenericExpr( * this ); }
    940         virtual void accept( Visitor & v ) override { v.visit( this ); }
    941         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    942         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    943         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     889        virtual GenericExpr * clone() const { return new GenericExpr( * this ); }
     890        virtual void accept( Visitor & v ) { v.visit( this ); }
     891        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     892        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    944893};
    945894
Note: See TracChangeset for help on using the changeset viewer.