dmd/aggregate.h

   1
   2 // Compiler implementation of the D programming language
   3 // Copyright (c) 1999-2008 by Digital Mars
   4 // All Rights Reserved
   5 // written by Walter Bright
   6 // http://www.digitalmars.com
   7 // License for redistribution is by either the Artistic License
   8 // in artistic.txt, or the GNU General Public License in gnu.txt.
   9 // See the included readme.txt for details.
  10
  11 /* NOTE: This file has been patched from the original DMD distribution to
  12    work with the GDC compiler.
  13
  14    Modified by David Friedman, December 2006
  15 */
  16
  17 #ifndef DMD_AGGREGATE_H
  18 #define DMD_AGGREGATE_H
  19
  20 #ifdef __DMC__
  21 #pragma once
  22 #endif /* __DMC__ */
  23
  24 #include "root.h"
  25 #include "dsymbol.h"
  26
  27 struct Identifier;
  28 struct Type;
  29 struct TypeFunction;
  30 struct Expression;
  31 struct FuncDeclaration;
  32 struct CtorDeclaration;
  33 struct DtorDeclaration;
  34 struct InvariantDeclaration;
  35 struct NewDeclaration;
  36 struct DeleteDeclaration;
  37 struct InterfaceDeclaration;
  38 struct ClassInfoDeclaration;
  39 struct VarDeclaration;
  40 struct dt_t;
  41
  42
  43 struct AggregateDeclaration : ScopeDsymbol
  44 {
  45     Type *type;
  46     unsigned storage_class;
  47     enum PROT protection;
  48     Type *handle;               // 'this' type
  49     target_size_t structsize;   // size of struct
  50     target_size_t alignsize;    // size of struct for alignment purposes
  51     target_size_t structalign;  // struct member alignment in effect
  52     int hasUnions;              // set if aggregate has overlapping fields
  53     Array fields;               // VarDeclaration fields
  54     unsigned sizeok;            // set when structsize contains valid data
  55                                 // 0: no size
  56                                 // 1: size is correct
  57                                 // 2: cannot determine size; fwd referenced
  58     int isdeprecated;           // !=0 if deprecated
  59     Scope *scope;               // !=NULL means context to use
  60
  61     // Special member functions
  62     InvariantDeclaration *inv;          // invariant
  63     NewDeclaration *aggNew;             // allocator
  64     DeleteDeclaration *aggDelete;       // deallocator
  65
  66     FuncDeclarations dtors;     // Array of destructors
  67     FuncDeclaration *dtor;      // aggregate destructor
  68
  69     Expressions * attributes;   // GCC decl/type attributes
  70 #ifdef IN_GCC
  71     Array methods;              // flat list of all methods for debug information
  72 #endif
  73
  74     AggregateDeclaration(Loc loc, Identifier *id);
  75     void semantic2(Scope *sc);
  76     void semantic3(Scope *sc);
  77     void inlineScan();
  78     target_size_t size(Loc loc);
  79     static void alignmember(target_size_t salign, target_size_t size, target_size_t *poffset);
  80     Type *getType();
  81     void addField(Scope *sc, VarDeclaration *v);
  82     int isDeprecated();         // is aggregate deprecated?
  83     FuncDeclaration *buildDtor(Scope *sc);
  84
  85     void emitComment(Scope *sc);
  86     void toDocBuffer(OutBuffer *buf);
  87
  88     // For access checking
  89     virtual PROT getAccess(Dsymbol *smember);   // determine access to smember
  90     int isFriendOf(AggregateDeclaration *cd);
  91     int hasPrivateAccess(Dsymbol *smember);     // does smember have private access to members of this class?
  92     void accessCheck(Loc loc, Scope *sc, Dsymbol *smember);
  93
  94     enum PROT prot();
  95
  96     // Back end
  97     Symbol *stag;               // tag symbol for debug data
  98     Symbol *sinit;
  99     Symbol *toInitializer();
 100
 101     AggregateDeclaration *isAggregateDeclaration() { return this; }
 102 };
 103
 104 struct AnonymousAggregateDeclaration : AggregateDeclaration
 105 {
 106     AnonymousAggregateDeclaration()
 107         : AggregateDeclaration(0, NULL)
 108     {
 109     }
 110
 111     AnonymousAggregateDeclaration *isAnonymousAggregateDeclaration() { return this; }
 112 };
 113
 114 struct StructDeclaration : AggregateDeclaration
 115 {
 116     int zeroInit;               // !=0 if initialize with 0 fill
 117 #if V2
 118     int hasIdentityAssign;      // !=0 if has identity opAssign
 119     FuncDeclaration *cpctor;    // generated copy-constructor, if any
 120
 121     FuncDeclarations postblits; // Array of postblit functions
 122     FuncDeclaration *postblit;  // aggregate postblit
 123 #endif
 124
 125     StructDeclaration(Loc loc, Identifier *id);
 126     Dsymbol *syntaxCopy(Dsymbol *s);
 127     void semantic(Scope *sc);
 128     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 129     char *mangle();
 130     char *kind();
 131     Expression *cloneMembers();
 132     void toDocBuffer(OutBuffer *buf);
 133
 134     PROT getAccess(Dsymbol *smember);   // determine access to smember
 135
 136     void toObjFile(int multiobj);                       // compile to .obj file
 137     void toDt(dt_t **pdt);
 138     void toDebug();                     // to symbolic debug info
 139
 140     StructDeclaration *isStructDeclaration() { return this; }
 141 };
 142
 143 struct UnionDeclaration : StructDeclaration
 144 {
 145     UnionDeclaration(Loc loc, Identifier *id);
 146     Dsymbol *syntaxCopy(Dsymbol *s);
 147     char *kind();
 148
 149     UnionDeclaration *isUnionDeclaration() { return this; }
 150 };
 151
 152 struct BaseClass
 153 {
 154     Type *type;                         // (before semantic processing)
 155     enum PROT protection;               // protection for the base interface
 156
 157     ClassDeclaration *base;
 158     target_ptrdiff_t offset;            // 'this' pointer offset
 159     Array vtbl;                         // for interfaces: Array of FuncDeclaration's
 160                                         // making up the vtbl[]
 161
 162     int baseInterfaces_dim;
 163     BaseClass *baseInterfaces;          // if BaseClass is an interface, these
 164                                         // are a copy of the InterfaceDeclaration::interfaces
 165
 166     BaseClass();
 167     BaseClass(Type *type, enum PROT protection);
 168
 169     int fillVtbl(ClassDeclaration *cd, Array *vtbl, int newinstance);
 170     void copyBaseInterfaces(BaseClasses *);
 171 };
 172
 173 extern int CLASSINFO_SIZE;              // value of ClassInfo.size
 174
 175 struct ClassDeclaration : AggregateDeclaration
 176 {
 177     static ClassDeclaration *object;
 178     static ClassDeclaration *classinfo;
 179
 180     ClassDeclaration *baseClass;        // NULL only if this is Object
 181     CtorDeclaration *ctor;
 182     CtorDeclaration *defaultCtor;       // default constructor
 183     FuncDeclaration *staticCtor;
 184     FuncDeclaration *staticDtor;
 185     Array vtbl;                         // Array of FuncDeclaration's making up the vtbl[]
 186     Array vtblFinal;                    // More FuncDeclaration's that aren't in vtbl[]
 187
 188     BaseClasses baseclasses;            // Array of BaseClass's; first is super,
 189                                         // rest are Interface's
 190
 191     int interfaces_dim;
 192     BaseClass **interfaces;             // interfaces[interfaces_dim] for this class
 193                                         // (does not include baseClass)
 194
 195     BaseClasses *vtblInterfaces;        // array of base interfaces that have
 196                                         // their own vtbl[]
 197
 198     ClassInfoDeclaration *vclassinfo;   // the ClassInfo object for this ClassDeclaration
 199     int com;                            // !=0 if this is a COM class (meaning
 200                                         // it derives from IUnknown)
 201     int isauto;                         // !=0 if this is an auto class
 202     int isabstract;                     // !=0 if abstract class
 203
 204     int isnested;                       // !=0 if is nested
 205     VarDeclaration *vthis;              // 'this' parameter if this class is nested
 206
 207     int inuse;                          // to prevent recursive attempts
 208
 209     ClassDeclaration(Loc loc, Identifier *id, BaseClasses *baseclasses);
 210     Dsymbol *syntaxCopy(Dsymbol *s);
 211     void semantic(Scope *sc);
 212     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 213     int isBaseOf2(ClassDeclaration *cd);
 214
 215     #define OFFSET_RUNTIME 0x76543210
 216     virtual int isBaseOf(ClassDeclaration *cd, target_ptrdiff_t *poffset);
 217
 218     Dsymbol *search(Loc, Identifier *ident, int flags);
 219 #if V2
 220     int isFuncHidden(FuncDeclaration *fd);
 221 #endif
 222     FuncDeclaration *findFunc(Identifier *ident, TypeFunction *tf);
 223     void interfaceSemantic(Scope *sc);
 224     int isNested();
 225     int isCOMclass();
 226     virtual int isCOMinterface();
 227 #if V2
 228     virtual int isCPPinterface();
 229 #endif
 230     int isAbstract();
 231     virtual int vtblOffset();
 232     char *kind();
 233     char *mangle();
 234     void toDocBuffer(OutBuffer *buf);
 235
 236     PROT getAccess(Dsymbol *smember);   // determine access to smember
 237
 238     void addLocalClass(ClassDeclarations *);
 239
 240     // Back end
 241     void toObjFile(int multiobj);                       // compile to .obj file
 242     void toDebug();
 243     unsigned baseVtblOffset(BaseClass *bc);
 244     Symbol *toSymbol();
 245     Symbol *toVtblSymbol();
 246     void toDt(dt_t **pdt);
 247     void toDt2(dt_t **pdt, ClassDeclaration *cd);
 248
 249     Symbol *vtblsym;
 250
 251     ClassDeclaration *isClassDeclaration() { return (ClassDeclaration *)this; }
 252 };
 253
 254 struct InterfaceDeclaration : ClassDeclaration
 255 {
 256 #if V2
 257     int cpp;                            // !=0 if this is a C++ interface
 258 #endif
 259     InterfaceDeclaration(Loc loc, Identifier *id, BaseClasses *baseclasses);
 260     Dsymbol *syntaxCopy(Dsymbol *s);
 261     void semantic(Scope *sc);
 262     int isBaseOf(ClassDeclaration *cd, target_ptrdiff_t *poffset);
 263     int isBaseOf(BaseClass *bc, target_ptrdiff_t *poffset);
 264     char *kind();
 265     int vtblOffset();
 266 #if V2
 267     int isCPPinterface();
 268 #endif
 269     virtual int isCOMinterface();
 270
 271     void toObjFile(int multiobj);                       // compile to .obj file
 272     Symbol *toSymbol();
 273
 274     InterfaceDeclaration *isInterfaceDeclaration() { return this; }
 275 };
 276
 277 #endif /* DMD_AGGREGATE_H */