Mercurial > projects > ldc
view dmd/mtype.h @ 444:f2b5f86348ef
Updated tango patch. tango.math.Math was incorrect.
author | Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> |
---|---|
date | Fri, 01 Aug 2008 01:12:33 +0200 |
parents | 3545f9eddbfc |
children | cc40db549aea |
line wrap: on
line source
// Compiler implementation of the D programming language // Copyright (c) 1999-2007 by Digital Mars // All Rights Reserved // written by Walter Bright // http://www.digitalmars.com // License for redistribution is by either the Artistic License // in artistic.txt, or the GNU General Public License in gnu.txt. // See the included readme.txt for details. #ifndef DMD_MTYPE_H #define DMD_MTYPE_H #ifdef __DMC__ #pragma once #endif /* __DMC__ */ #include "root.h" #include "stringtable.h" #include "arraytypes.h" #include "expression.h" // llvm #include "../ir/irtype.h" struct Scope; struct Identifier; struct Expression; struct StructDeclaration; struct ClassDeclaration; struct VarDeclaration; struct EnumDeclaration; struct TypedefDeclaration; struct TypeInfoDeclaration; struct Dsymbol; struct TemplateInstance; enum LINK; struct TypeBasic; struct HdrGenState; // Back end #if IN_GCC union tree_node; typedef union tree_node TYPE; typedef TYPE type; #else typedef struct TYPE type; #endif struct Symbol; enum TY { Tarray, // dynamic array Tsarray, // static array Taarray, // associative array Tpointer, Treference, Tfunction, Tident, Tclass, Tstruct, Tenum, Ttypedef, Tdelegate, Tnone, Tvoid, Tint8, Tuns8, Tint16, Tuns16, Tint32, Tuns32, Tint64, Tuns64, Tfloat32, Tfloat64, Tfloat80, Timaginary32, Timaginary64, Timaginary80, Tcomplex32, Tcomplex64, Tcomplex80, Tbit, Tbool, Tchar, Twchar, Tdchar, Terror, Tinstance, Ttypeof, Ttuple, Tslice, // LLVMDC Topaque, TMAX }; #define Tascii Tchar extern int Tsize_t; extern int Tptrdiff_t; struct Type : Object { TY ty; unsigned char mod; // modifiers (MODconst, MODinvariant) #define MODconst 1 // type is const #define MODinvariant 2 // type is invariant Type *next; char *deco; Type *pto; // merged pointer to this type Type *rto; // reference to this type Type *arrayof; // array of this type TypeInfoDeclaration *vtinfo; // TypeInfo object for this Type type *ctype; // for back end #define tvoid basic[Tvoid] #define tint8 basic[Tint8] #define tuns8 basic[Tuns8] #define tint16 basic[Tint16] #define tuns16 basic[Tuns16] #define tint32 basic[Tint32] #define tuns32 basic[Tuns32] #define tint64 basic[Tint64] #define tuns64 basic[Tuns64] #define tfloat32 basic[Tfloat32] #define tfloat64 basic[Tfloat64] #define tfloat80 basic[Tfloat80] #define timaginary32 basic[Timaginary32] #define timaginary64 basic[Timaginary64] #define timaginary80 basic[Timaginary80] #define tcomplex32 basic[Tcomplex32] #define tcomplex64 basic[Tcomplex64] #define tcomplex80 basic[Tcomplex80] #define tbit basic[Tbit] #define tbool basic[Tbool] #define tchar basic[Tchar] #define twchar basic[Twchar] #define tdchar basic[Tdchar] // Some special types #define tshiftcnt tint32 // right side of shift expression // #define tboolean tint32 // result of boolean expression #define tboolean tbool // result of boolean expression #define tindex tint32 // array/ptr index static Type *tvoidptr; // void* #define terror basic[Terror] // for error recovery #define tsize_t basic[Tsize_t] // matches size_t alias #define tptrdiff_t basic[Tptrdiff_t] // matches ptrdiff_t alias #define thash_t tsize_t // matches hash_t alias static ClassDeclaration *typeinfo; static ClassDeclaration *typeinfoclass; static ClassDeclaration *typeinfointerface; static ClassDeclaration *typeinfostruct; static ClassDeclaration *typeinfotypedef; static ClassDeclaration *typeinfopointer; static ClassDeclaration *typeinfoarray; static ClassDeclaration *typeinfostaticarray; static ClassDeclaration *typeinfoassociativearray; static ClassDeclaration *typeinfoenum; static ClassDeclaration *typeinfofunction; static ClassDeclaration *typeinfodelegate; static ClassDeclaration *typeinfotypelist; // LLVMDC, for runtime function signatures that contain // AAs or arrays of unknown type static Type* topaque; static Type *basic[TMAX]; static unsigned char mangleChar[TMAX]; static StringTable stringtable; // These tables are for implicit conversion of binary ops; // the indices are the type of operand one, followed by operand two. static unsigned char impcnvResult[TMAX][TMAX]; static unsigned char impcnvType1[TMAX][TMAX]; static unsigned char impcnvType2[TMAX][TMAX]; // If !=0, give warning on implicit conversion static unsigned char impcnvWarn[TMAX][TMAX]; Type(TY ty, Type *next); virtual Type *syntaxCopy(); int equals(Object *o); int dyncast() { return DYNCAST_TYPE; } // kludge for template.isType() int covariant(Type *t); char *toChars(); static char needThisPrefix(); static void init(); d_uns64 size(); virtual d_uns64 size(Loc loc); virtual unsigned alignsize(); virtual Type *semantic(Loc loc, Scope *sc); virtual void toDecoBuffer(OutBuffer *buf); Type *merge(); virtual void toCBuffer(OutBuffer *buf, Identifier *ident, HdrGenState *hgs); virtual void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); void toCBuffer3(OutBuffer *buf, HdrGenState *hgs, int mod); virtual int isbit(); virtual int isintegral(); virtual int isfloating(); // real, imaginary, or complex virtual int isreal(); virtual int isimaginary(); virtual int iscomplex(); virtual int isscalar(); virtual int isunsigned(); virtual int isauto(); virtual int isString(); virtual int checkBoolean(); // if can be converted to boolean value void checkDeprecated(Loc loc, Scope *sc); Type *pointerTo(); Type *referenceTo(); Type *arrayOf(); virtual Dsymbol *toDsymbol(Scope *sc); virtual Type *toBasetype(); virtual int isBaseOf(Type *t, int *poffset); virtual MATCH implicitConvTo(Type *to); virtual ClassDeclaration *isClassHandle(); virtual Expression *getProperty(Loc loc, Identifier *ident); virtual Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); virtual unsigned memalign(unsigned salign); virtual Expression *defaultInit(Loc loc = 0); virtual int isZeroInit(); // if initializer is 0 virtual dt_t **toDt(dt_t **pdt); Identifier *getTypeInfoIdent(int internal); virtual MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes); virtual void resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps); Expression *getInternalTypeInfo(Scope *sc); Expression *getTypeInfo(Scope *sc); virtual TypeInfoDeclaration *getTypeInfoDeclaration(); virtual int builtinTypeInfo(); virtual Type *reliesOnTident(); virtual Expression *toExpression(); virtual int hasPointers(); Type *nextOf() { return next; } static void error(Loc loc, const char *format, ...); // For backend virtual unsigned totym(); virtual type *toCtype(); virtual type *toCParamtype(); virtual Symbol *toSymbol(); // For eliminating dynamic_cast virtual TypeBasic *isTypeBasic(); // llvmdc IrType ir; }; struct TypeBasic : Type { char *dstring; char *cstring; unsigned flags; TypeBasic(TY ty); Type *syntaxCopy(); d_uns64 size(Loc loc); unsigned alignsize(); Expression *getProperty(Loc loc, Identifier *ident); Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); char *toChars(); void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); int isintegral(); int isbit(); int isfloating(); int isreal(); int isimaginary(); int iscomplex(); int isscalar(); int isunsigned(); MATCH implicitConvTo(Type *to); Expression *defaultInit(Loc loc); int isZeroInit(); int builtinTypeInfo(); // For eliminating dynamic_cast TypeBasic *isTypeBasic(); }; struct TypeArray : Type { TypeArray(TY ty, Type *next); Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); }; // Static array, one with a fixed dimension struct TypeSArray : TypeArray { Expression *dim; TypeSArray(Type *t, Expression *dim); Type *syntaxCopy(); d_uns64 size(Loc loc); unsigned alignsize(); Type *semantic(Loc loc, Scope *sc); void resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps); void toDecoBuffer(OutBuffer *buf); void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); int isString(); int isZeroInit(); unsigned memalign(unsigned salign); MATCH implicitConvTo(Type *to); Expression *defaultInit(Loc loc); dt_t **toDt(dt_t **pdt); dt_t **toDtElem(dt_t **pdt, Expression *e); MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes); TypeInfoDeclaration *getTypeInfoDeclaration(); Expression *toExpression(); int hasPointers(); type *toCtype(); type *toCParamtype(); }; // Dynamic array, no dimension struct TypeDArray : TypeArray { TypeDArray(Type *t); Type *syntaxCopy(); d_uns64 size(Loc loc); unsigned alignsize(); Type *semantic(Loc loc, Scope *sc); void toDecoBuffer(OutBuffer *buf); void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); int isString(); int isZeroInit(); int checkBoolean(); MATCH implicitConvTo(Type *to); Expression *defaultInit(Loc loc); int builtinTypeInfo(); TypeInfoDeclaration *getTypeInfoDeclaration(); int hasPointers(); type *toCtype(); }; struct TypeAArray : TypeArray { Type *index; // key type for type checking Type *key; // actual key type TypeAArray(Type *t, Type *index); Type *syntaxCopy(); d_uns64 size(Loc loc); Type *semantic(Loc loc, Scope *sc); void resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps); void toDecoBuffer(OutBuffer *buf); void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); Expression *defaultInit(Loc loc); MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes); int isZeroInit(); int checkBoolean(); TypeInfoDeclaration *getTypeInfoDeclaration(); int hasPointers(); // Back end Symbol *aaGetSymbol(char *func, int flags); type *toCtype(); }; struct TypePointer : Type { TypePointer(Type *t); Type *syntaxCopy(); Type *semantic(Loc loc, Scope *sc); d_uns64 size(Loc loc); void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); MATCH implicitConvTo(Type *to); int isscalar(); // LLVMDC: pointers are unsigned int isunsigned() { return TRUE; }; Expression *defaultInit(Loc loc); int isZeroInit(); TypeInfoDeclaration *getTypeInfoDeclaration(); int hasPointers(); type *toCtype(); }; struct TypeReference : Type { TypeReference(Type *t); Type *syntaxCopy(); d_uns64 size(Loc loc); void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); Expression *defaultInit(Loc loc); int isZeroInit(); }; enum RET { RETregs = 1, // returned in registers RETstack = 2, // returned on stack }; struct TypeFunction : Type { Arguments *parameters; // function parameters int varargs; // 1: T t, ...) style for variable number of arguments // 2: T t ...) style for variable number of arguments enum LINK linkage; // calling convention int inuse; TypeFunction(Arguments *parameters, Type *treturn, int varargs, enum LINK linkage); Type *syntaxCopy(); Type *semantic(Loc loc, Scope *sc); void toDecoBuffer(OutBuffer *buf); void toCBuffer(OutBuffer *buf, Identifier *ident, HdrGenState *hgs); void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes); TypeInfoDeclaration *getTypeInfoDeclaration(); Type *reliesOnTident(); int callMatch(Expressions *toargs); type *toCtype(); enum RET retStyle(); unsigned totym(); bool llvmRetInPtr; bool llvmUsesThis; }; struct TypeDelegate : Type { TypeDelegate(Type *t); Type *syntaxCopy(); Type *semantic(Loc loc, Scope *sc); d_uns64 size(Loc loc); void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); Expression *defaultInit(Loc loc); int isZeroInit(); int checkBoolean(); TypeInfoDeclaration *getTypeInfoDeclaration(); Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); int hasPointers(); type *toCtype(); }; struct TypeQualified : Type { Loc loc; Array idents; // array of Identifier's representing ident.ident.ident etc. TypeQualified(TY ty, Loc loc); void syntaxCopyHelper(TypeQualified *t); void addIdent(Identifier *ident); void toCBuffer2Helper(OutBuffer *buf, HdrGenState *hgs); d_uns64 size(Loc loc); void resolveHelper(Loc loc, Scope *sc, Dsymbol *s, Dsymbol *scopesym, Expression **pe, Type **pt, Dsymbol **ps); }; struct TypeIdentifier : TypeQualified { Identifier *ident; TypeIdentifier(Loc loc, Identifier *ident); Type *syntaxCopy(); //char *toChars(); void toDecoBuffer(OutBuffer *buf); void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); void resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps); Dsymbol *toDsymbol(Scope *sc); Type *semantic(Loc loc, Scope *sc); MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes); Type *reliesOnTident(); Expression *toExpression(); }; /* Similar to TypeIdentifier, but with a TemplateInstance as the root */ struct TypeInstance : TypeQualified { TemplateInstance *tempinst; TypeInstance(Loc loc, TemplateInstance *tempinst); Type *syntaxCopy(); //char *toChars(); //void toDecoBuffer(OutBuffer *buf); void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); void resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps); Type *semantic(Loc loc, Scope *sc); MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes); }; struct TypeTypeof : TypeQualified { Expression *exp; TypeTypeof(Loc loc, Expression *exp); Type *syntaxCopy(); Dsymbol *toDsymbol(Scope *sc); void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); Type *semantic(Loc loc, Scope *sc); d_uns64 size(Loc loc); }; struct TypeStruct : Type { StructDeclaration *sym; TypeStruct(StructDeclaration *sym); d_uns64 size(Loc loc); unsigned alignsize(); char *toChars(); Type *syntaxCopy(); Type *semantic(Loc loc, Scope *sc); Dsymbol *toDsymbol(Scope *sc); void toDecoBuffer(OutBuffer *buf); void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); unsigned memalign(unsigned salign); Expression *defaultInit(Loc loc); int isZeroInit(); int checkBoolean(); dt_t **toDt(dt_t **pdt); MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes); TypeInfoDeclaration *getTypeInfoDeclaration(); int hasPointers(); type *toCtype(); }; struct TypeEnum : Type { EnumDeclaration *sym; TypeEnum(EnumDeclaration *sym); d_uns64 size(Loc loc); unsigned alignsize(); char *toChars(); Type *semantic(Loc loc, Scope *sc); Dsymbol *toDsymbol(Scope *sc); void toDecoBuffer(OutBuffer *buf); void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); Expression *getProperty(Loc loc, Identifier *ident); int isintegral(); int isfloating(); int isscalar(); int isunsigned(); MATCH implicitConvTo(Type *to); Type *toBasetype(); Expression *defaultInit(Loc loc); int isZeroInit(); MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes); TypeInfoDeclaration *getTypeInfoDeclaration(); int hasPointers(); type *toCtype(); }; struct TypeTypedef : Type { TypedefDeclaration *sym; TypeTypedef(TypedefDeclaration *sym); Type *syntaxCopy(); d_uns64 size(Loc loc); unsigned alignsize(); char *toChars(); Type *semantic(Loc loc, Scope *sc); Dsymbol *toDsymbol(Scope *sc); void toDecoBuffer(OutBuffer *buf); void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); Expression *getProperty(Loc loc, Identifier *ident); int isbit(); int isintegral(); int isfloating(); int isreal(); int isimaginary(); int iscomplex(); int isscalar(); int isunsigned(); int checkBoolean(); Type *toBasetype(); MATCH implicitConvTo(Type *to); Expression *defaultInit(Loc loc); int isZeroInit(); dt_t **toDt(dt_t **pdt); MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes); TypeInfoDeclaration *getTypeInfoDeclaration(); int hasPointers(); type *toCtype(); type *toCParamtype(); }; struct TypeClass : Type { ClassDeclaration *sym; TypeClass(ClassDeclaration *sym); d_uns64 size(Loc loc); char *toChars(); Type *syntaxCopy(); Type *semantic(Loc loc, Scope *sc); Dsymbol *toDsymbol(Scope *sc); void toDecoBuffer(OutBuffer *buf); void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); ClassDeclaration *isClassHandle(); int isBaseOf(Type *t, int *poffset); MATCH implicitConvTo(Type *to); Expression *defaultInit(Loc loc); int isZeroInit(); MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes); int isauto(); int checkBoolean(); TypeInfoDeclaration *getTypeInfoDeclaration(); int hasPointers(); type *toCtype(); Symbol *toSymbol(); }; struct TypeTuple : Type { Arguments *arguments; // types making up the tuple TypeTuple(Arguments *arguments); TypeTuple(Expressions *exps); Type *syntaxCopy(); Type *semantic(Loc loc, Scope *sc); int equals(Object *o); Type *reliesOnTident(); void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); void toDecoBuffer(OutBuffer *buf); Expression *getProperty(Loc loc, Identifier *ident); TypeInfoDeclaration *getTypeInfoDeclaration(); }; struct TypeSlice : Type { Expression *lwr; Expression *upr; TypeSlice(Type *next, Expression *lwr, Expression *upr); Type *syntaxCopy(); Type *semantic(Loc loc, Scope *sc); void resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps); void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); }; //LLVMDC struct TypeOpaque : Type { TypeOpaque() : Type(Topaque, NULL) {} void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); }; /**************************************************************/ //enum InOut { None, In, Out, InOut, Lazy }; struct Argument : Object { //enum InOut inout; unsigned storageClass; Type *type; Identifier *ident; Expression *defaultArg; Argument(unsigned storageClass, Type *type, Identifier *ident, Expression *defaultArg); Argument *syntaxCopy(); Type *isLazyArray(); void toDecoBuffer(OutBuffer *buf); static Arguments *arraySyntaxCopy(Arguments *args); static char *argsTypesToChars(Arguments *args, int varargs); static void argsToCBuffer(OutBuffer *buf, HdrGenState *hgs, Arguments *arguments, int varargs); static void argsToDecoBuffer(OutBuffer *buf, Arguments *arguments); static size_t dim(Arguments *arguments); static Argument *getNth(Arguments *arguments, size_t nth, size_t *pn = NULL); // LLVMDC bool llvmByVal; }; extern int PTRSIZE; extern int REALSIZE; extern int REALPAD; extern int Tsize_t; extern int Tptrdiff_t; #endif /* DMD_MTYPE_H */