Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/SynTree/Expression.h

    rd807ca28 r849720f  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Sep  3 19:23:46 2017
    13 // Update Count     : 48
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Thr Aug 15 13:46:00 2019
     13// Update Count     : 54
    1414//
    1515
    … …  
    2121#include <memory>                 // for allocator, unique_ptr
    2222#include <string>                 // for string
     23#include <vector>                 // for vector
    2324
    2425#include "BaseSyntaxNode.h"       // for BaseSyntaxNode
    … …  
    3839/// but subject to decay-to-pointer and type parameter renaming
    3940struct ParamEntry {
    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 ) {}
     41        ParamEntry(): decl( 0 ), declptr( nullptr ), actualType( nullptr ), formalType( nullptr ), expr( nullptr ) {}
     42        ParamEntry( UniqueId decl, Declaration * declptr, Type * actualType, Type * formalType, Expression* expr );
    4243        ParamEntry( const ParamEntry & other );
    4344        ParamEntry( ParamEntry && other );
    4445        ~ParamEntry();
    45         ParamEntry & operator=( const ParamEntry & other );
    4646        ParamEntry & operator=( ParamEntry && other );
    4747
    48         UniqueId decl;
    49         Type * actualType;
    50         Type * formalType;
     48        UniqueId const decl;
     49        Declaration * const declptr;
     50        Type * const actualType;
     51        Type * const formalType;
    5152        Expression * expr;
    52         std::unique_ptr< InferredParams > inferParams;
    5353};
    5454
    … …  
    5959        TypeSubstitution * env;
    6060        bool extension = false;
    61         InferredParams inferParams;
     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
    6265
    6366        Expression();
    … …  
    6871        const Type * get_result() const { return result; }
    6972        void set_result( Type * newValue ) { result = newValue; }
     73        virtual bool get_lvalue() const;
    7074
    7175        TypeSubstitution * get_env() const { return env; }
    … …  
    7478        Expression * set_extension( bool exten ) { extension = exten; return this; }
    7579
    76         InferredParams & get_inferParams() { return inferParams; }
    77 
    7880        // move other's inferParams to this
    7981        void spliceInferParams( Expression * other );
    … …  
    8183        virtual Expression * clone() const override = 0;
    8284        virtual void accept( Visitor & v ) override = 0;
     85        virtual void accept( Visitor & v ) const override = 0;
    8386        virtual Expression * acceptMutator( Mutator & m ) override = 0;
    8487        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    9699        virtual ~ApplicationExpr();
    97100
     101        bool get_lvalue() const final;
     102
    98103        Expression * get_function() const { return function; }
    99104        void set_function( Expression * newValue ) { function = newValue; }
    100105        std::list<Expression *>& get_args() { return args; }
    101106
    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;
     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;
    106112};
    107113
    … …  
    118124        virtual ~UntypedExpr();
    119125
     126        bool get_lvalue() const final;
     127
    120128        Expression * get_function() const { return function; }
    121129        void set_function( Expression * newValue ) { function = newValue; }
    … …  
    128136        static UntypedExpr * createAssign( Expression * arg1, Expression * arg2 );
    129137
    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;
     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;
    134143};
    135144
    … …  
    146155        void set_name( std::string newValue ) { name = newValue; }
    147156
    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;
     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;
    152162};
    153163
    … …  
    167177        void set_arg(Expression * newValue ) { arg = newValue; }
    168178
    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;
     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;
    173184};
    174185
    … …  
    183194        virtual ~LabelAddressExpr();
    184195
    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;
     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;
    189201};
    190202
    … …  
    193205  public:
    194206        Expression * arg;
    195         bool isGenerated = true; // whether this cast appeared in the source program
     207        bool isGenerated = true; // cast generated implicitly by code generation or explicit in program
    196208
    197209        CastExpr( Expression * arg, bool isGenerated = true );
    … …  
    201213        virtual ~CastExpr();
    202214
     215        bool get_lvalue() const final;
     216
    203217        Expression * get_arg() const { return arg; }
    204218        void set_arg( Expression * newValue ) { arg = newValue; }
    205219
    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;
     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;
    210225};
    211226
    … …  
    224239        const std::string & targetString() const;
    225240
    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;
     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;
    230246};
    231247
    … …  
    242258        void set_arg( Expression * newValue ) { arg = newValue; }
    243259
    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;
     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;
    248265};
    249266
    … …  
    257274        UntypedMemberExpr( const UntypedMemberExpr & other );
    258275        virtual ~UntypedMemberExpr();
     276
     277        bool get_lvalue() const final;
    259278
    260279        Expression * get_member() const { return member; }
    … …  
    263282        void set_aggregate( Expression * newValue ) { aggregate = newValue; }
    264283
    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;
     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;
    269289};
    270290
    … …  
    279299        MemberExpr( const MemberExpr & other );
    280300        virtual ~MemberExpr();
     301
     302        bool get_lvalue() const final;
    281303
    282304        DeclarationWithType * get_member() const { return member; }
    … …  
    285307        void set_aggregate( Expression * newValue ) { aggregate = newValue; }
    286308
    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;
     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;
    291314};
    292315
    … …  
    297320        DeclarationWithType * var;
    298321
     322        VariableExpr();
    299323        VariableExpr( DeclarationWithType * var );
    300324        VariableExpr( const VariableExpr & other );
    301325        virtual ~VariableExpr();
    302326
     327        bool get_lvalue() const final;
     328
    303329        DeclarationWithType * get_var() const { return var; }
    304330        void set_var( DeclarationWithType * newValue ) { var = newValue; }
    … …  
    306332        static VariableExpr * functionPointer( FunctionDecl * decl );
    307333
    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;
     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;
    312339};
    313340
    … …  
    327354        long long int intValue() const;
    328355
    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;
     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;
    333361};
    334362
    … …  
    352380        void set_isType( bool newValue ) { isType = newValue; }
    353381
    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;
     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;
    358387};
    359388
    … …  
    377406        void set_isType( bool newValue ) { isType = newValue; }
    378407
    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;
     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;
    383413};
    384414
    … …  
    398428        void set_type( Type * newValue ) { type = newValue; }
    399429
    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;
     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;
    404435};
    405436
    … …  
    419450        void set_member( DeclarationWithType * newValue ) { member = newValue; }
    420451
    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;
     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;
    425457};
    426458
    … …  
    437469        void set_type( StructInstType * newValue ) { type = newValue; }
    438470
    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)
    446 class 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;
     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;
    471476};
    472477
    … …  
    487492        void set_arg2( Expression * newValue ) { arg2 = newValue; }
    488493
    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;
     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;
    493499
    494500  private:
    … …  
    506512        ConditionalExpr( const ConditionalExpr & other );
    507513        virtual ~ConditionalExpr();
     514
     515        bool get_lvalue() const final;
    508516
    509517        Expression * get_arg1() const { return arg1; }
    … …  
    514522        void set_arg3( Expression * newValue ) { arg3 = newValue; }
    515523
    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;
     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;
    520529};
    521530
    … …  
    529538        CommaExpr( const CommaExpr & other );
    530539        virtual ~CommaExpr();
     540
     541        bool get_lvalue() const final;
    531542
    532543        Expression * get_arg1() const { return arg1; }
    … …  
    535546        void set_arg2( Expression * newValue ) { arg2 = newValue; }
    536547
    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;
     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;
    541553};
    542554
    … …  
    553565        void set_type( Type * newValue ) { type = newValue; }
    554566
    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;
     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;
    559572};
    560573
    … …  
    579592        void set_operand( Expression * newValue ) { operand = newValue; }
    580593
    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;
     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;
    585599
    586600        // https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
    … …  
    591605class ImplicitCopyCtorExpr : public Expression {
    592606public:
    593         ApplicationExpr * callExpr;
    594         std::list< ObjectDecl * > tempDecls;
    595         std::list< ObjectDecl * > returnDecls;
    596         std::list< Expression * > dtors;
     607        ApplicationExpr * callExpr = nullptr;
    597608
    598609        ImplicitCopyCtorExpr( ApplicationExpr * callExpr );
    … …  
    600611        virtual ~ImplicitCopyCtorExpr();
    601612
    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;
     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;
    613618};
    614619
    … …  
    622627        ~ConstructorExpr();
    623628
     629        bool get_lvalue() const final;
     630
    624631        Expression * get_callExpr() const { return callExpr; }
    625632        void set_callExpr( Expression * newValue ) { callExpr = newValue; }
    626633
    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;
     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;
    631639};
    632640
    … …  
    640648        virtual ~CompoundLiteralExpr();
    641649
     650        bool get_lvalue() const final;
     651
    642652        Initializer * get_initializer() const { return initializer; }
    643653        void set_initializer( Initializer * i ) { initializer = i; }
    644654
    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;
     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;
    649660};
    650661
    … …  
    662673        RangeExpr * set_high( Expression * high ) { RangeExpr::high = high; return this; }
    663674
    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;
     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;
    668680};
    669681
    … …  
    679691        std::list<Expression*>& get_exprs() { return exprs; }
    680692
    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;
     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;
    685698};
    686699
    … …  
    694707        virtual ~TupleExpr();
    695708
     709        bool get_lvalue() const final;
     710
    696711        std::list<Expression*>& get_exprs() { return exprs; }
    697712
    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;
     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;
    702718};
    703719
    … …  
    711727        TupleIndexExpr( const TupleIndexExpr & other );
    712728        virtual ~TupleIndexExpr();
     729
     730        bool get_lvalue() const final;
    713731
    714732        Expression * get_tuple() const { return tuple; }
    … …  
    717735        TupleIndexExpr * set_index( unsigned int newValue ) { index = newValue; return this; }
    718736
    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;
     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;
    723742};
    724743
    … …  
    735754        StmtExpr * get_stmtExpr() const { return stmtExpr; }
    736755
    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;
     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 );
    741765};
    742766
    … …  
    748772        std::list< Expression * > dtors; // destructor(s) for return variable(s)
    749773
     774        // readonly
     775        ExprStmt * resultExpr = nullptr;
     776
    750777        StmtExpr( CompoundStmt * statements );
    751778        StmtExpr( const StmtExpr & other );
    752779        virtual ~StmtExpr();
    753780
     781        bool get_lvalue() const final;
     782
    754783        CompoundStmt * get_statements() const { return statements; }
    755784        StmtExpr * set_statements( CompoundStmt * newValue ) { statements = newValue; return this; }
    … …  
    761790        std::list< Expression * > & get_dtors() { return dtors; }
    762791
    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;
     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;
    767797};
    768798
    … …  
    788818        int get_id() const { return id; }
    789819
    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;
     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;
    794825
    795826private:
    … …  
    822853        std::list<InitAlternative> & get_initAlts() { return initAlts; }
    823854
    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;
     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;
    828860};
    829861
    … …  
    843875        InitExpr * set_designation( Designation * newValue ) { designation = newValue; return this; }
    844876
    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;
     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;
    849882};
    850883
    … …  
    853886public:
    854887        Expression * expr;
    855         BaseSyntaxNode * deleteStmt;
    856 
    857         DeletedExpr( Expression * expr, BaseSyntaxNode * deleteStmt );
     888        Declaration * deleteStmt;
     889
     890        DeletedExpr( Expression * expr, Declaration * deleteStmt );
    858891        DeletedExpr( const DeletedExpr & other );
    859892        ~DeletedExpr();
    860893
    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;
     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.
     902class DefaultArgExpr : public Expression {
     903public:
     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;
    865915};
    866916
    … …  
    887937        virtual ~GenericExpr();
    888938
    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;
     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;
    893944};
    894945
Note: See TracChangeset for help on using the changeset viewer.