projects/dil: trunk/src/dil/semantic/Types.d comparison

comparison trunk/src/dil/semantic/Types.d @ 798:c24be8d4f6ab

Added documentation comments.

author	Aziz K?ksal <aziz.koeksal@gmail.com>
date	Sat, 01 Mar 2008 02:53:06 +0100
parents	f7688996bf08
children	9e6c6bb73e5f

comparison

equal deleted inserted replaced

-:cf2ad5df025c
+:c24be8d4f6ab
 import dil.semantic.Symbol;
 import dil.semantic.TypesEnum;
 import dil.lexer.Identifier;
 import dil.CompilerInfo;
+/// The base type for all type structures.
 abstract class Type/* : Symbol*/
 {
 Type next;     /// The next type in the type structure.
 TYP tid;       /// The ID of the type.
 Symbol symbol; /// Not null if this type has a symbol.
 this(){}
+/// Constructs a Type object.
+/// Params:
+///   next = the type's next type.
+///   tid = the type's ID.
 this(Type next, TYP tid)
 {
 //     this.sid = SYM.Type;
 this.next = next;
 this.tid = tid;
 }
+/// Returns a pointer type to this type.
 TypePointer ptrTo()
 {
 return new TypePointer(this);
 }
-/// Get byte size of this type.
+/// Returns the byte size of this type.
 final size_t sizeOf()
 {
 return MITable.getSize(this);
 }
 size_t sizeOf_()
 {
 return sizeOf();
 }
+/// Returns true if this type has a symbol.
 bool hasSymbol()
 {
 return symbol !is null;
 }
 }
+/// All basic types. E.g.: int, char, real etc.
 class TypeBasic : Type
 {
 this(TYP typ)
 {
 super(null, typ);
 }
 }
-/// Dynamic array.
+/// Dynamic array type.
 class TypeDArray : Type
 {
 this(Type next)
 {
 super(next, TYP.DArray);
 }
 }
-/// Associative array.
+/// Associative array type.
 class TypeAArray : Type
 {
 Type keyType;
 this(Type next, Type keyType)
 {
 super(next, TYP.AArray);
 this.keyType = keyType;
 }
 }
-/// Static array.
+/// Static array type.
 class TypeSArray : Type
 {
 size_t dimension;
 this(Type next, size_t dimension)
 {
 super(next, TYP.SArray);
 this.dimension = dimension;
 }
 }
+/// Pointer type.
 class TypePointer : Type
 {
 this(Type next)
 {
 super(next, TYP.Pointer);
 }
 }
+/// Reference type.
 class TypeReference : Type
 {
 this(Type next)
 {
 super(next, TYP.Reference);
 }
 }
+/// Enum type.
 class TypeEnum : Type
 {
 this(Symbol symbol, Type baseType)
 {
 super(baseType, TYP.Enum);
 {
 return next;
 }
 }
+/// Struct type.
 class TypeStruct : Type
 {
 this(Symbol symbol)
 {
 super(null, TYP.Struct);
 this.symbol = symbol;
 }
 }
+/// Class type.
 class TypeClass : Type
 {
 this(Symbol symbol)
 {
 super(null, TYP.Class);
 this.symbol = symbol;
 }
 }
+/// Typedef type.
 class TypeTypedef : Type
 {
 this(Type next)
 {
 super(next, TYP.Typedef);
 }
 }
+/// Function type.
 class TypeFunction : Type
 {
 this(Type next)
 {
 super(next, TYP.Function);
 }
 }
+/// Delegate type.
 class TypeDelegate : Type
 {
 this(Type next)
 {
 super(next, TYP.Delegate);
 }
 }
+/// Identifier type.
 class TypeIdentifier : Type
 {
 Identifier* ident;
 this(Identifier* ident)
 {
 super(null, TYP.Identifier);
 }
 }
+/// Template instantiation type.
 class TypeTemplInstance : Type
 {
 this()
 {
 super(null, TYP.TInstance);
 }
 }
+/// Template tuple type.
 class TypeTuple : Type
 {
 this(Type next)
 {
 super(next, TYP.Tuple);
 }
 }
+/// Constant type. D2.0
 class TypeConst : Type
 {
 this(Type next)
 {
 super(next, TYP.Const);
 }
 }
+/// Invariant type. D2.0
 class TypeInvariant : Type
 {
 this(Type next)
 {
 super(next, TYP.Const);
 }
 }
-/// Represents a value related to a type.
+/// Represents a value related to a Type.
 union Value
 {
 void*  pvoid;
 bool   bool_;
 dchar  dchar_;
 double double_;
 real   real_;
 creal  creal_;
 }
+/// Information related to a Type.
 struct TypeMetaInfo
 {
 char mangle; /// Mangle character of the type.
 ushort size; /// Byte size of the type.
 Value* defaultInit; /// Default initialization value.
 }
+/// Namespace for the meta info table.
 struct MITable
 {
 static:
 const ushort SIZE_NOT_AVAILABLE = 0; /// Size not available.
 const Value VZERO = {int_:0}; /// Value 0.
 const Value VFALSE = {bool_:false}; /// Value false.
 const Value VNAN = {float_:float.nan}; /// Value NAN.
 const Value VCNAN = {creal_:creal.nan}; /// Value complex NAN.
 private alias SIZE_NOT_AVAILABLE SNA;
 private alias PTR_SIZE PS;
+/// The meta info table.
 private const TypeMetaInfo metaInfoTable[] = [
 {'?', SNA}, // Error
 {'a', 1, &V0xFF},   // Char
 {'u', 2, &V0xFFFF},   // Wchar
 {'x', SNA}, // Const, D2
 {'y', SNA}, // Invariant, D2
 ];
 static assert(metaInfoTable.length == TYP.max+1);
+/// Returns the size of a type.
 size_t getSize(Type type)
 {
 auto size = metaInfoTable[type.tid].size;
 if (size == SIZE_NOT_AVAILABLE)
 return type.sizeOf_();
 return size;
 }
 }
-/// A set of pre-defined types.
+/// Namespace for a set of predefined types.
 struct Types
 {
 static:
+/// Predefined basic types.
 TypeBasic Char,   Wchar,   Dchar, Bool,
 Byte,   Ubyte,   Short, Ushort,
 Int,    Uint,    Long,  Ulong,
 Cent,   Ucent,
 Float,  Double,  Real,
 Ifloat, Idouble, Ireal,
 Cfloat, Cdouble, Creal, Void;
-TypeBasic Size_t, Ptrdiff_t;
+TypeBasic Size_t; /// The size type.
-TypePointer Void_ptr;
+TypeBasic Ptrdiff_t; /// The pointer difference type.
-TypeBasic Error, Undefined;
+TypePointer Void_ptr; /// The void pointer type.
+TypeBasic Error; /// The error type.
+TypeBasic Undefined; /// The undefined type.
 /// Allocates an instance of TypeBasic and assigns it to typeName.
 template newTB(char[] typeName)
 {
 const newTB = mixin(typeName~" = new TypeBasic(TYP."~typeName~")");
 }
+/// Initializes predefined types.
 static this()
 {
 newTB!("Char");
 newTB!("Wchar");
 newTB!("Dchar");

Mercurial > projects > dil

comparison trunk/src/dil/semantic/Types.d @ 798:c24be8d4f6ab