Mercurial > projects > dang

annotate sema/DType.d @ 129:ed815b31479b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added a Symbol
author Anders Halager <halager@gmail.com>
date Sat, 21 Jun 2008 20:41:18 +0200
parents 7d0898f77685
children a101853eaae0
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
1 module sema.DType;
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
2
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
3 import lexer.Token,
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
4 ast.Exp;
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
5
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
6 public
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
7 import sema.Operation;
28
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out.
Anders Johnsen <skabet@gmail.com>
parents: 27
diff changeset
8
129
ed815b31479b Added a Symbol
Anders Halager <halager@gmail.com>
parents: 120
diff changeset
9 ///
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
10 class DType
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
11 {
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
12 private char[] id;
88
eb5b2c719a39 Major change to locations, tokens and expressions.
Anders Halager <halager@gmail.com>
parents: 83
diff changeset
13 private SourceLocation loc;
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
14 public DType actual;
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
15
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
16 this(Identifier id, DType actual = null)
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
17 {
88
eb5b2c719a39 Major change to locations, tokens and expressions.
Anders Halager <halager@gmail.com>
parents: 83
diff changeset
18 this.id = id.name;
eb5b2c719a39 Major change to locations, tokens and expressions.
Anders Halager <halager@gmail.com>
parents: 83
diff changeset
19 this.loc = id.startLoc();
49
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
20 this.actual = actual is null? this : actual;
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
21 }
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
22
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
23 this(char[] id, DType actual = null)
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
24 {
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
25 this.id = id;
49
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
26 this.actual = actual is null? this : actual;
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
27 }
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
28
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
29 /// Is this type a DStruct
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
30 bool isStruct() { return false; }
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
31 /// Return a DStruct if this is one, otherwise return null
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
32 DStruct asStruct() { return null; }
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
33
72
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
34 /// Is this type a DArray
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
35 bool isArray() { return false; }
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
36 /// Return a DArray if this is one, otherwise return null
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
37 DArray asArray() { return null; }
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
38
77
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
39 /// Is this type a DPointer
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
40 bool isPointer() { return false; }
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
41 /// Return a DPointer if this is one, otherwise return null
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
42 DPointer asPointer() { return null; }
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
43
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
44 /// Is this type a DFunction
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
45 bool isFunction() { return false; }
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
46 /// Return a DFunction if this is one, otherwise return null
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
47 DFunction asFunction() { return null; }
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
48
116
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
49 /// Returns true for integers, reals and complex numbers
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
50 bool isArithmetic() { return false; }
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
51
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
52 /// Is this type a DInteger
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
53 bool isInteger() { return false; }
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
54 /// Return a DInteger if this is one, otherwise return null
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
55 DInteger asInteger() { return null; }
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
56
116
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
57 /// Is this type a DReal
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
58 bool isReal() { return false; }
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
59 /// Return a DReal if this is one, otherwise return null
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
60 DReal asReal() { return null; }
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
61
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
62 int opEquals(Object o)
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
63 {
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
64 if (auto t = cast(DType)o)
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
65 return this.actual is t.actual;
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
66 return 0;
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
67 }
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
68
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
69 int opCmp(Object o)
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
70 {
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
71 if (auto t = cast(DType)o)
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
72 return cast(void*)this.actual - cast(void*)t.actual;
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
73 return 0;
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
74 }
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
75
49
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
76 /**
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
77 Hashing is done by casting the reference to a void* and taking that
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
78 value, but this gives a bad distribution of hash-values.
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
79
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
80 Multiple DType's allocated close to each other will only have a
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
81 difference in the lower bits of their hashes.
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
82 */
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
83 hash_t toHash()
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
84 {
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
85 return cast(hash_t)(cast(void*)this);
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
86 }
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
87
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
88 char[] name() { return id; }
88
eb5b2c719a39 Major change to locations, tokens and expressions.
Anders Halager <halager@gmail.com>
parents: 83
diff changeset
89 SourceLocation getLoc() { return loc; }
39
1a7a308f75b2 Added some struct tests, and implemented a wrong struct assignment
Anders Halager <halager@gmail.com>
parents: 37
diff changeset
90 int byteSize() { return 0; }
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
91
58
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
92 /**
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
93 Can this type legally be converted to that type with no casts?
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
94 True for short -> int etc.
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
95 */
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
96 bool hasImplicitConversionTo(DType that) { return false; }
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
97
83
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 81
diff changeset
98 /**
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
99 Get an Operation describing how to use the supplied operator on the two
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
100 types given.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
101 */
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
102 Operation getOperationWith(Operator op, DType other)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
103 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
104 Operation res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
105 return res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
106 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
108 /**
83
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 81
diff changeset
109 Get a type representing a pointer to this type (from int to int*)
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 81
diff changeset
110 */
80
682e20aa224f Pointers working now - big YAY
Anders Johnsen <skabet@gmail.com>
parents: 77
diff changeset
111 DPointer getPointerTo()
682e20aa224f Pointers working now - big YAY
Anders Johnsen <skabet@gmail.com>
parents: 77
diff changeset
112 {
682e20aa224f Pointers working now - big YAY
Anders Johnsen <skabet@gmail.com>
parents: 77
diff changeset
113 if(myPointer !is null)
682e20aa224f Pointers working now - big YAY
Anders Johnsen <skabet@gmail.com>
parents: 77
diff changeset
114 return myPointer;
682e20aa224f Pointers working now - big YAY
Anders Johnsen <skabet@gmail.com>
parents: 77
diff changeset
115 myPointer = new DPointer(this);
682e20aa224f Pointers working now - big YAY
Anders Johnsen <skabet@gmail.com>
parents: 77
diff changeset
116 return myPointer;
682e20aa224f Pointers working now - big YAY
Anders Johnsen <skabet@gmail.com>
parents: 77
diff changeset
117 }
83
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 81
diff changeset
118 private DPointer myPointer;
80
682e20aa224f Pointers working now - big YAY
Anders Johnsen <skabet@gmail.com>
parents: 77
diff changeset
119
96
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
120 /**
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
121 Mangle the DType following the specs at http://digitalmars.com/d/1.0/abi.html
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
122 **/
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
123 char[] mangle()
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
124 {
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
125 /// expects to be void
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
126 return "v";
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
127 }
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
128
83
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 81
diff changeset
129 /**
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 81
diff changeset
130 Get a type representing a static array of this type with length 'size'
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 81
diff changeset
131 */
81
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
132 DArray getAsArray(int size)
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
133 {
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
134 if(size in myArray)
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
135 return myArray[size];
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
136 myArray[size] = new DArray(this, size);
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
137 return myArray[size];
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
138 }
83
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 81
diff changeset
139 private DArray[int] myArray;
81
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
140
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
141 static DInteger
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
142 Bool,
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
143 Byte, UByte, Short, UShort,
103
09b4d74cb3f5 Parsing char, wchar and dchar as basic types.
Anders Johnsen <skabet@gmail.com>
parents: 96
diff changeset
144 Int, UInt, Long, ULong,
09b4d74cb3f5 Parsing char, wchar and dchar as basic types.
Anders Johnsen <skabet@gmail.com>
parents: 96
diff changeset
145 Char, WChar, DChar;
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
146
116
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
147 static DReal Float, Double, Real;
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
148
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
149 // Ignore - we dont support complex numbers yet
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
150 static DReal CFloat, CDouble, CReal;
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
151
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
152 static DType Void;
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
153
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
154 static this()
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
155 {
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
156 Void = new DType("void");
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
157
129
ed815b31479b Added a Symbol
Anders Halager <halager@gmail.com>
parents: 120
diff changeset
158 Bool = new DInteger("bool", 1, true);
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
159 Byte = new DInteger("byte", 8, false);
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
160 UByte = new DInteger("ubyte", 8, true);
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
161 Short = new DInteger("short", 16, false);
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
162 UShort = new DInteger("ushort", 16, true);
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
163 Int = new DInteger("int", 32, false);
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
164 UInt = new DInteger("uint", 32, true);
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
165 Long = new DInteger("long", 64, false);
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
166 ULong = new DInteger("ulong", 64, true);
116
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
167
118
54585ad7e426 Added the DType -> llvm type mapping for some more types
Anders Halager <halager@gmail.com>
parents: 116
diff changeset
168 Float = new DReal("float", 32);
116
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
169 Double = new DReal("double", 64);
118
54585ad7e426 Added the DType -> llvm type mapping for some more types
Anders Halager <halager@gmail.com>
parents: 116
diff changeset
170 Real = new DReal("real", 80);
116
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
171
103
09b4d74cb3f5 Parsing char, wchar and dchar as basic types.
Anders Johnsen <skabet@gmail.com>
parents: 96
diff changeset
172 Char = new DInteger("char", 8, true);
09b4d74cb3f5 Parsing char, wchar and dchar as basic types.
Anders Johnsen <skabet@gmail.com>
parents: 96
diff changeset
173 WChar = new DInteger("wchar", 16, true);
09b4d74cb3f5 Parsing char, wchar and dchar as basic types.
Anders Johnsen <skabet@gmail.com>
parents: 96
diff changeset
174 DChar = new DInteger("dchar", 32, true);
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
175 }
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
176 }
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
177
49
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
178 /**
116
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
179 Class to represent the built-in numerical types, from byte to long, reals and
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
180 complex numbers.
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
181
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
182 Should not actually use this, but DInteger, DReal or DComplex.
49
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
183 */
116
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
184 class DArithmetic : DType
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
185 {
116
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
186 private static char[][DArithmetic] mangle_types;
96
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
187
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
188 static this()
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
189 {
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
190 mangle_types =
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
191 [
116
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
192 cast(DArithmetic)
96
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
193 Bool : "b",
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
194 Byte : "g",
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
195 UByte : "h",
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
196 Short : "s",
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
197 UShort : "t",
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
198 Int : "i",
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
199 UInt : "k",
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
200 Long : "l",
116
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
201 ULong : "m",
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
202
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
203 Float : "f",
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
204 Double : "d",
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
205 Real : "e",
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
206
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
207 /*
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
208 CFloat : "q",
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
209 CDouble : "r",
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
210 CReal : "c",
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
211 */
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
212
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
213 Char : "a",
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
214 WChar : "u",
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
215 DChar : "w"
96
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
216 ];
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
217 }
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
218
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
219 this(char[] name, int bits, bool unsigned)
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
220 {
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
221 super(name, null);
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
222 this.bits = bits;
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
223 this.unsigned = unsigned;
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
224 }
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
225
39
1a7a308f75b2 Added some struct tests, and implemented a wrong struct assignment
Anders Halager <halager@gmail.com>
parents: 37
diff changeset
226 override int byteSize() { return bits / 8; }
1a7a308f75b2 Added some struct tests, and implemented a wrong struct assignment
Anders Halager <halager@gmail.com>
parents: 37
diff changeset
227
116
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
228 bool isArithmetic() { return true; }
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
229
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
230 override Operation getOperationWith(Operator op, DType that)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
231 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
232 Operation operation;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
233 if (this is that)
116
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
234 operation = Operation.builtin(op, unsigned, isReal());
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
235 return operation;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
236 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 103
diff changeset
237
96
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
238 override char[] mangle()
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
239 {
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
240 return mangle_types[this];
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
241 }
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
242
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
243 int bits;
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
244 bool unsigned;
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
245 }
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
246
116
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
247 class DInteger : DArithmetic
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
248 {
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
249 this(char[] name, int bits, bool unsigned)
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
250 {
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
251 super(name, bits, unsigned);
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
252 }
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
253
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
254 override bool hasImplicitConversionTo(DType that)
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
255 {
120
7d0898f77685 Implement the cast expression - works for integers and real/float/double
Anders Halager <halager@gmail.com>
parents: 119
diff changeset
256 if (that.isInteger() || that.isReal())
116
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
257 return true;
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
258 return false;
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
259 }
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
260
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
261 override bool isInteger() { return true; }
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
262 override DInteger asInteger() { return this; }
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
263 }
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
264
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
265 class DReal : DArithmetic
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
266 {
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
267 this(char[] name, int bits)
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
268 {
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
269 super(name, bits, false);
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
270 }
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
271
119
c0b531362ca6 Non compileing commit. Work on floating points and casts
Anders Johnsen <skabet@gmail.com>
parents: 118
diff changeset
272 override bool hasImplicitConversionTo(DType that)
c0b531362ca6 Non compileing commit. Work on floating points and casts
Anders Johnsen <skabet@gmail.com>
parents: 118
diff changeset
273 {
120
7d0898f77685 Implement the cast expression - works for integers and real/float/double
Anders Halager <halager@gmail.com>
parents: 119
diff changeset
274 if (that.isInteger() || that.isReal())
119
c0b531362ca6 Non compileing commit. Work on floating points and casts
Anders Johnsen <skabet@gmail.com>
parents: 118
diff changeset
275 return true;
c0b531362ca6 Non compileing commit. Work on floating points and casts
Anders Johnsen <skabet@gmail.com>
parents: 118
diff changeset
276 return false;
c0b531362ca6 Non compileing commit. Work on floating points and casts
Anders Johnsen <skabet@gmail.com>
parents: 118
diff changeset
277 }
c0b531362ca6 Non compileing commit. Work on floating points and casts
Anders Johnsen <skabet@gmail.com>
parents: 118
diff changeset
278
116
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
279 override bool isReal() { return true; }
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
280 override DReal asReal() { return this; }
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
281 }
0cd8d6ab3f89 Add in the types for float and co.
Anders Halager <halager@gmail.com>
parents: 107
diff changeset
282
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
283 class DStruct : DType
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
284 {
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
285 this(Identifier id, DType actual = null)
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
286 {
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
287 super(id, actual);
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
288 }
28
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out.
Anders Johnsen <skabet@gmail.com>
parents: 27
diff changeset
289
39
1a7a308f75b2 Added some struct tests, and implemented a wrong struct assignment
Anders Halager <halager@gmail.com>
parents: 37
diff changeset
290 int byteSize() { return bytes_total; }
1a7a308f75b2 Added some struct tests, and implemented a wrong struct assignment
Anders Halager <halager@gmail.com>
parents: 37
diff changeset
291
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
292 override bool isStruct() { return true; }
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
293 override DStruct asStruct() { return this; }
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
294
55
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
295 void addMember(DType type, char[] name)
28
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out.
Anders Johnsen <skabet@gmail.com>
parents: 27
diff changeset
296 {
55
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
297 auto s = DStructMember(type, members.length);
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
298 members[name] = s;
28
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out.
Anders Johnsen <skabet@gmail.com>
parents: 27
diff changeset
299
55
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
300 bytes_total += type.byteSize();
49
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
301 }
28
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out.
Anders Johnsen <skabet@gmail.com>
parents: 27
diff changeset
302
55
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
303 int indexOf(char[] name)
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
304 {
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
305 if(name in members)
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
306 return members[name].index;
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
307
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
308 return -1;
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
309 }
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
310
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
311 DType typeOf(char[] name)
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
312 {
58
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
313 if (auto res = name in members)
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
314 return res.type;
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
315 return null;
55
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
316 }
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
317
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
318 DStructMember[char[]] members;
39
1a7a308f75b2 Added some struct tests, and implemented a wrong struct assignment
Anders Halager <halager@gmail.com>
parents: 37
diff changeset
319 private int bytes_total;
55
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
320
96
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
321 override char[] mangle()
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
322 {
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
323 return "S"~Integer.toString(name.length)~name;
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
324 }
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
325
55
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
326 struct DStructMember
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
327 {
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
328 DType type;
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
329 int index;
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
330 }
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
331 }
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
332
72
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
333 class DArray : DType
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
334 {
81
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
335 this(DType arrayOf, int size, DType actual = null)
72
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
336 {
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
337 super(id, actual);
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
338 this.arrayOf = arrayOf;
81
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
339 this.size = size;
72
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
340 }
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
341
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
342 override bool isArray() { return true; }
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
343 override DArray asArray() { return this; }
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
344
81
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
345 int byteSize() { return arrayOf.byteSize * size; }
72
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
346
96
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
347 override char[] mangle()
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
348 {
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
349 return "G"~Integer.toString(size)~arrayOf.mangle;
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
350 }
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
351
72
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
352 DType arrayOf;
81
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
353 const int size;
72
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
354 }
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
355
77
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
356 class DPointer : DType
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
357 {
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
358 this(DType pointerOf, DType actual = null)
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
359 {
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
360 super(id, actual);
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
361 this.pointerOf = pointerOf;
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
362 }
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
363
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
364 override bool isPointer() { return true; }
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
365 override DPointer asPointer() { return this; }
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
366
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
367 int byteSize() { return DType.Int.byteSize; }
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
368
96
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
369 override char[] mangle()
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
370 {
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
371 return "P"~pointerOf.mangle;
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
372 }
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
373
77
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
374 DType pointerOf;
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
375 }
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
376
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
377 class DFunction : DType
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
378 {
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
379 this(Identifier id, DType actual = null)
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
380 {
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
381 super(id, actual);
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
382 }
49
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
383
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
384 override bool isFunction() { return true; }
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
385 override DFunction asFunction() { return this; }
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
386
96
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
387 override char[] mangle()
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
388 {
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
389 char[] res;
129
ed815b31479b Added a Symbol
Anders Halager <halager@gmail.com>
parents: 120
diff changeset
390
96
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
391 res ~= "F";
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
392
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
393 foreach(param ; params)
129
ed815b31479b Added a Symbol
Anders Halager <halager@gmail.com>
parents: 120
diff changeset
394 res ~= param.mangle;
96
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
395
129
ed815b31479b Added a Symbol
Anders Halager <halager@gmail.com>
parents: 120
diff changeset
396 res ~= "Z";
ed815b31479b Added a Symbol
Anders Halager <halager@gmail.com>
parents: 120
diff changeset
397 res ~= returnType.mangle;
96
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
398
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
399 return res;
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
400 }
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
401
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
402 DType[] params;
63
9f8131676242 Now Decl's have a DType type(), and should use varType and returnType to get the old type id
Anders Halager <halager@gmail.com>
parents: 58
diff changeset
403 DType returnType;
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
404 bool firstParamIsReturnValue = false;
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
405 }
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
406