source: translator/SynTree/Type.h @ c8ffe20b

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsctordeferred_resndemanglerenumforall-pointer-decaygc_noraiijacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newstringwith_gc
Last change on this file since c8ffe20b was c8ffe20b, checked in by Peter A. Buhr <pabuhr@…>, 9 years ago

reformat files

  • Property mode set to 100644
File size: 15.4 KB
RevLine 
[51b7345]1#ifndef TYPE_H
2#define TYPE_H
3
4#include "SynTree.h"
5#include "Visitor.h"
6#include "Mutator.h"
7
8
[c8ffe20b]9class Type {
10  public:
11    struct Qualifiers { 
12      Qualifiers(): isConst( false ), isVolatile( false ), isRestrict( false ), isLvalue( false ) {}
13      Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue ): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ) {}
[51b7345]14       
[c8ffe20b]15        Qualifiers &operator+=( const Qualifiers &other );
16        Qualifiers &operator-=( const Qualifiers &other );
[51b7345]17        Qualifiers operator+( const Type::Qualifiers &other );
[c8ffe20b]18        bool operator==( const Qualifiers &other );
19        bool operator!=( const Qualifiers &other );
[51b7345]20        bool operator<=( const Qualifiers &other );
21        bool operator>=( const Qualifiers &other );
22        bool operator<( const Qualifiers &other );
23        bool operator>( const Qualifiers &other );
24       
25        bool isConst;
26        bool isVolatile;
27        bool isRestrict;
28        bool isLvalue;
29    }; 
30
31    Type( const Qualifiers &tq );
32    Type( const Type &other );
33    virtual ~Type();
34
35    Qualifiers &get_qualifiers() { return tq; }
36    bool get_isConst() { return tq.isConst; }
37    bool get_isVolatile() { return tq.isVolatile; }
38    bool get_isRestrict() { return tq.isRestrict; }
39    bool get_isLvalue() { return tq.isLvalue; }
40    void set_isConst( bool newValue ) { tq.isConst = newValue; }
41    void set_iisVolatile( bool newValue ) { tq.isVolatile = newValue; }
42    void set_isRestrict( bool newValue ) { tq.isRestrict = newValue; }
43    void set_isLvalue( bool newValue ) { tq.isLvalue = newValue; }
44    std::list<TypeDecl*>& get_forall() { return forall; }
45
46    virtual Type *clone() const = 0;
47    virtual void accept( Visitor &v ) = 0;
48    virtual Type *acceptMutator( Mutator &m ) = 0;
49    virtual void print( std::ostream &os, int indent = 0 ) const;
[c8ffe20b]50  private:
[51b7345]51    Qualifiers tq;
52    std::list<TypeDecl*> forall;
53};
54
[c8ffe20b]55class VoidType : public Type {
56  public:
[51b7345]57    VoidType( const Type::Qualifiers &tq );
58
59    virtual VoidType *clone() const { return new VoidType( *this ); }
60    virtual void accept( Visitor &v ) { v.visit( this ); }
61    virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
62    virtual void print( std::ostream &os, int indent = 0 ) const;
63};
64
[c8ffe20b]65class BasicType : public Type {
66  public:
67    enum Kind { 
68        Bool,
69        Char,
70        SignedChar,
71        UnsignedChar,
72        ShortSignedInt,
73        ShortUnsignedInt,
74        SignedInt,
75        UnsignedInt,
76        LongSignedInt,
77        LongUnsignedInt,
78        LongLongSignedInt,
79        LongLongUnsignedInt,
80        Float,
81        Double,
82        LongDouble,
83        FloatComplex,
84        DoubleComplex,
85        LongDoubleComplex,
86        FloatImaginary,
87        DoubleImaginary,
88        LongDoubleImaginary,
89        NUMBER_OF_BASIC_TYPES
90    }; 
[51b7345]91
92    BasicType( const Type::Qualifiers &tq, Kind bt );
93
94    Kind get_kind() { return kind; }
95    void set_kind( Kind newValue ) { kind = newValue; }
96
97    virtual BasicType *clone() const { return new BasicType( *this ); }
98    virtual void accept( Visitor &v ) { v.visit( this ); }
99    virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
100    virtual void print( std::ostream &os, int indent = 0 ) const;
101
102    bool isInteger() const;
[c8ffe20b]103  private:
[51b7345]104    Kind kind;
105};
106
[c8ffe20b]107class PointerType : public Type {
108  public:
[51b7345]109    PointerType( const Type::Qualifiers &tq, Type *base );
110    PointerType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
111    PointerType( const PointerType& );
112    virtual ~PointerType();
113
114    Type *get_base() { return base; }
115    void set_base( Type *newValue ) { base = newValue; }
116    Expression *get_dimension() { return dimension; }
117    void set_dimension( Expression *newValue ) { dimension = newValue; }
118    bool get_isVarLen() { return isVarLen; }
119    void set_isVarLen( bool newValue ) { isVarLen = newValue; }
120    bool get_isStatic() { return isStatic; }
121    void set_isStatic( bool newValue ) { isStatic = newValue; }
122
123    virtual PointerType *clone() const { return new PointerType( *this ); }
124    virtual void accept( Visitor &v ) { v.visit( this ); }
125    virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
126    virtual void print( std::ostream &os, int indent = 0 ) const;
[c8ffe20b]127  private:
[51b7345]128    Type *base;
129   
[c8ffe20b]130    // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
[51b7345]131    Expression *dimension;
132    bool isVarLen;
133    bool isStatic;
134};
135
[c8ffe20b]136class ArrayType : public Type {
137  public:
[51b7345]138    ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
139    ArrayType( const ArrayType& );
140    virtual ~ArrayType();
141
142    Type *get_base() { return base; }
143    void set_base( Type *newValue ) { base = newValue; }
144    Expression *get_dimension() { return dimension; }
145    void set_dimension( Expression *newValue ) { dimension = newValue; }
146    bool get_isVarLen() { return isVarLen; }
147    void set_isVarLen( bool newValue ) { isVarLen = newValue; }
148    bool get_isStatic() { return isStatic; }
149    void set_isStatic( bool newValue ) { isStatic = newValue; }
150
151    virtual ArrayType *clone() const { return new ArrayType( *this ); }
152    virtual void accept( Visitor &v ) { v.visit( this ); }
153    virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
154    virtual void print( std::ostream &os, int indent = 0 ) const;
[c8ffe20b]155  private:
[51b7345]156    Type *base;
157    Expression *dimension;
158    bool isVarLen;
159    bool isStatic;
160};
161
[c8ffe20b]162class FunctionType : public Type {
163  public:
[51b7345]164    FunctionType( const Type::Qualifiers &tq, bool isVarArgs );
165    FunctionType( const FunctionType& );
166    virtual ~FunctionType();
167
168    std::list<DeclarationWithType*>& get_returnVals() { return returnVals; }
169    std::list<DeclarationWithType*>& get_parameters() { return parameters; }
170    bool get_isVarArgs() { return isVarArgs; }
171    void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
172
173    virtual FunctionType *clone() const { return new FunctionType( *this ); }
174    virtual void accept( Visitor &v ) { v.visit( this ); }
175    virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
176    virtual void print( std::ostream &os, int indent = 0 ) const;
[c8ffe20b]177  private:
[51b7345]178    std::list<DeclarationWithType*> returnVals;
179    std::list<DeclarationWithType*> parameters;
180
181    // does the function accept a variable number of arguments following the arguments
182    // specified in the parameters list.    This could be because of
183    // - an ellipsis in a prototype declaration
184    // - an unprototyped declaration
185    bool isVarArgs;
186};
187
[c8ffe20b]188class ReferenceToType : public Type {
189  public:
[51b7345]190    ReferenceToType( const Type::Qualifiers &tq, const std::string &name );
191    ReferenceToType( const ReferenceToType &other );
192    virtual ~ReferenceToType();
193
194    std::string get_name() const { return name; }
195    void set_name( std::string newValue ) { name = newValue; }
196    std::list< Expression* >& get_parameters() { return parameters; }
197   
198    virtual ReferenceToType *clone() const = 0;
199    virtual void accept( Visitor &v ) = 0;
200    virtual Type *acceptMutator( Mutator &m ) = 0;
201    virtual void print( std::ostream &os, int indent = 0 ) const;
[c8ffe20b]202  protected:
[51b7345]203    virtual std::string typeString() const = 0;
204    std::list< Expression* > parameters;
[c8ffe20b]205  private:
[51b7345]206    std::string name;
207};
208
[c8ffe20b]209class StructInstType : public ReferenceToType {
[51b7345]210    typedef ReferenceToType Parent;
[c8ffe20b]211  public:
[51b7345]212    StructInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ), baseStruct( 0 ) {}
213    StructInstType( const StructInstType &other ) : Parent( other ), baseStruct( other.baseStruct ) {}
214
215    StructDecl *get_baseStruct() const { return baseStruct; }
216    void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
217   
218    // a utility function
219    void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
220
221    virtual StructInstType *clone() const { return new StructInstType( *this ); }
222    virtual void accept( Visitor &v ) { v.visit( this ); }
223    virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
224
[c8ffe20b]225  private:
[51b7345]226    virtual std::string typeString() const;
227   
228    // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
229    // where the structure used in this type is actually defined
230    StructDecl *baseStruct;
231};
232
[c8ffe20b]233class UnionInstType : public ReferenceToType {
[51b7345]234    typedef ReferenceToType Parent;
[c8ffe20b]235  public:
[51b7345]236    UnionInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ), baseUnion( 0 ) {}
237    UnionInstType( const UnionInstType &other ) : Parent( other ), baseUnion( other.baseUnion ) {}
238
239    UnionDecl *get_baseUnion() const { return baseUnion; }
240    void set_baseUnion( UnionDecl *newValue ) { baseUnion = newValue; }
241   
242    // a utility function
243    void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
244
245    virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
246    virtual void accept( Visitor &v ) { v.visit( this ); }
247    virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
[c8ffe20b]248  private:
[51b7345]249    virtual std::string typeString() const;
250   
251    // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
252    // where the union used in this type is actually defined
253    UnionDecl *baseUnion;
254};
255
[c8ffe20b]256class EnumInstType : public ReferenceToType {
[51b7345]257    typedef ReferenceToType Parent;
[c8ffe20b]258  public:
[51b7345]259    EnumInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ) {}
260    EnumInstType( const EnumInstType &other ) : Parent( other ) {}
261
262    virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
263    virtual void accept( Visitor &v ) { v.visit( this ); }
264    virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
265
[c8ffe20b]266  private:
[51b7345]267    virtual std::string typeString() const;
268};
269
[c8ffe20b]270class ContextInstType : public ReferenceToType {
[51b7345]271    typedef ReferenceToType Parent;
[c8ffe20b]272  public:
[51b7345]273    ContextInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ) {}
274    ContextInstType( const ContextInstType &other );
275    ~ContextInstType();
276
277    std::list< Declaration* >& get_members() { return members; }
278
279    virtual ContextInstType *clone() const { return new ContextInstType( *this ); }
280    virtual void accept( Visitor &v ) { v.visit( this ); }
281    virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
[c8ffe20b]282  private:
[51b7345]283    virtual std::string typeString() const;
284   
285    // this member is filled in by the validate pass, which instantiates the members of the correponding
286    // aggregate with the actual type parameters specified for this use of the context
287    std::list< Declaration* > members;
288};
289
[c8ffe20b]290class TypeInstType : public ReferenceToType {
[51b7345]291    typedef ReferenceToType Parent;
[c8ffe20b]292  public:
[51b7345]293    TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType );
294    TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype );
295    TypeInstType( const TypeInstType &other ) : Parent( other ), baseType( other.baseType ), isFtype( other.isFtype ) {}
296
297    TypeDecl *get_baseType() const { return baseType; }
298    void set_baseType( TypeDecl *newValue );
299    bool get_isFtype() const { return isFtype; }
300    void set_isFtype( bool newValue ) { isFtype = newValue; }
301   
302    virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
303    virtual void accept( Visitor &v ) { v.visit( this ); }
304    virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
305    virtual void print( std::ostream &os, int indent = 0 ) const;
[c8ffe20b]306  private:
[51b7345]307    virtual std::string typeString() const;
308    // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
309    // where the type used here is actually defined
310    TypeDecl *baseType;
311    bool isFtype;
312};
313
[c8ffe20b]314class TupleType : public Type {
315  public:
[51b7345]316    TupleType( const Type::Qualifiers &tq );
317    TupleType( const TupleType& );
318    virtual ~TupleType();
319
320    std::list<Type*>& get_types() { return types; }
321
322    virtual TupleType *clone() const { return new TupleType( *this ); }
323    virtual void accept( Visitor &v ) { v.visit( this ); }
324    virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
325    virtual void print( std::ostream &os, int indent = 0 ) const;
[c8ffe20b]326  private:
[51b7345]327    std::list<Type*> types;
328};
329
[c8ffe20b]330class TypeofType : public Type {
331  public:
[51b7345]332    TypeofType( const Type::Qualifiers &tq, Expression *expr );
333    TypeofType( const TypeofType& );
334    virtual ~TypeofType();
335
336    Expression *get_expr() const { return expr; }
337    void set_expr( Expression *newValue ) { expr = newValue; }
338
339    virtual TypeofType *clone() const { return new TypeofType( *this ); }
340    virtual void accept( Visitor &v ) { v.visit( this ); }
341    virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
342    virtual void print( std::ostream &os, int indent = 0 ) const;
[c8ffe20b]343  private:
[51b7345]344    Expression *expr;
345};
346
[c8ffe20b]347class AttrType : public Type {
348  public:
[51b7345]349    AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr );
350    AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type );
351    AttrType( const AttrType& );
352    virtual ~AttrType();
353
354    std::string get_name() const { return name; }
355    void set_name( const std::string &newValue ) { name = newValue; }
356    Expression *get_expr() const { return expr; }
357    void set_expr( Expression *newValue ) { expr = newValue; }
358    Type *get_type() const { return type; }
359    void set_type( Type *newValue ) { type = newValue; }
360    bool get_isType() const { return isType; }
361    void set_isType( bool newValue ) { isType = newValue; }
362
363    virtual AttrType *clone() const { return new AttrType( *this ); }
364    virtual void accept( Visitor &v ) { v.visit( this ); }
365    virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
366    virtual void print( std::ostream &os, int indent = 0 ) const;
367
[c8ffe20b]368  private:
[51b7345]369    std::string name;
370    Expression *expr;
371    Type *type;
372    bool isType;
373};
374
[c8ffe20b]375inline Type::Qualifiers &Type::Qualifiers::operator+=( const Type::Qualifiers &other ) {
[51b7345]376    isConst |= other.isConst;
377    isVolatile |= other.isVolatile;
378    isRestrict |= other.isRestrict;
379    isLvalue |= other.isLvalue;
380    return *this;
381}
382
[c8ffe20b]383inline Type::Qualifiers &Type::Qualifiers::operator-=( const Type::Qualifiers &other ) {
384    if ( other.isConst ) isConst = 0;
385    if ( other.isVolatile ) isVolatile = 0;
386    if ( other.isRestrict ) isRestrict = 0;
[51b7345]387    return *this;
388}
389
[c8ffe20b]390inline Type::Qualifiers Type::Qualifiers::operator+( const Type::Qualifiers &other ) {
[51b7345]391    Qualifiers q = other;
392    q += *this;
393    return q;
394}
395
[c8ffe20b]396inline bool Type::Qualifiers::operator==( const Qualifiers &other ) {
[51b7345]397    return isConst == other.isConst
[c8ffe20b]398    && isVolatile == other.isVolatile
399    && isRestrict == other.isRestrict;
[51b7345]400///         && isLvalue == other.isLvalue;
401}
402
[c8ffe20b]403inline bool Type::Qualifiers::operator!=( const Qualifiers &other ) {
[51b7345]404    return isConst != other.isConst
405        || isVolatile != other.isVolatile
406        || isRestrict != other.isRestrict;
407///         && isLvalue == other.isLvalue;
408}
409
[c8ffe20b]410inline bool Type::Qualifiers::operator<=( const Type::Qualifiers &other ) {
[51b7345]411    return isConst <= other.isConst
412        && isVolatile <= other.isVolatile
413        && isRestrict <= other.isRestrict;
414///         && isLvalue >= other.isLvalue;
415}
416
[c8ffe20b]417inline bool Type::Qualifiers::operator>=( const Type::Qualifiers &other ) {
[51b7345]418    return isConst >= other.isConst
419        && isVolatile >= other.isVolatile
420        && isRestrict >= other.isRestrict;
421///         && isLvalue <= other.isLvalue;
422}
423
[c8ffe20b]424inline bool Type::Qualifiers::operator<( const Type::Qualifiers &other ) {
[51b7345]425    return operator!=( other ) && operator<=( other );
426}
427
[c8ffe20b]428inline bool Type::Qualifiers::operator>( const Type::Qualifiers &other ) {
[51b7345]429    return operator!=( other ) && operator>=( other );
430}
431
[c8ffe20b]432#endif // TYPE_H
Note: See TracBrowser for help on using the repository browser.