Mercurial > projects > dang

annotate sema/DType.d @ 96:438e6ed4cda1 new_gen

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
author Anders Johnsen <skabet@gmail.com>
date Tue, 06 May 2008 18:51:08 +0200
parents eb5b2c719a39
children 09b4d74cb3f5
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
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
6 import tango.io.Stdout;
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
7
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
8 class DType
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
9 {
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
10 private char[] id;
88
eb5b2c719a39 Major change to locations, tokens and expressions.
Anders Halager <halager@gmail.com>
parents: 83
diff changeset
11 private SourceLocation loc;
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
12 public DType actual;
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
13
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
14 this(Identifier id, DType actual = null)
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
15 {
88
eb5b2c719a39 Major change to locations, tokens and expressions.
Anders Halager <halager@gmail.com>
parents: 83
diff changeset
16 this.id = id.name;
eb5b2c719a39 Major change to locations, tokens and expressions.
Anders Halager <halager@gmail.com>
parents: 83
diff changeset
17 this.loc = id.startLoc();
49
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
18 this.actual = actual is null? this : actual;
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
19 }
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
20
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
21 this(char[] id, DType actual = null)
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
22 {
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
23 this.id = id;
49
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
24 this.actual = actual is null? this : actual;
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
25 }
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
26
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
27 /// 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
28 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
29 /// 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
30 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
31
72
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
32 /// Is this type a DArray
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
33 bool isArray() { return false; }
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
34 /// 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
35 DArray asArray() { return null; }
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
36
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
37 /// 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
38 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
39 /// 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
40 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
41
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
42 /// 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
43 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
44 /// 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
45 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
46
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
47 /// 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
48 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
49 /// 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
50 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
51
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
52 int opEquals(Object o)
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
53 {
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
54 if (auto t = cast(DType)o)
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
55 return this.actual is t.actual;
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
56 return 0;
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
57 }
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
58
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
59 int opCmp(Object o)
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
60 {
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
61 if (auto t = cast(DType)o)
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
62 return cast(void*)this.actual - cast(void*)t.actual;
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
63 return 0;
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
64 }
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
65
49
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
66 /**
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
67 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
68 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
69
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
70 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
71 difference in the lower bits of their hashes.
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
72 */
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
73 hash_t toHash()
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 return cast(hash_t)(cast(void*)this);
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
76 }
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
77
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
78 char[] name() { return id; }
88
eb5b2c719a39 Major change to locations, tokens and expressions.
Anders Halager <halager@gmail.com>
parents: 83
diff changeset
79 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
80 int byteSize() { return 0; }
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
81
58
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
82 /**
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
83 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
84 True for short -> int etc.
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
85 */
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
86 bool hasImplicitConversionTo(DType that) { return false; }
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
87
83
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 81
diff changeset
88 /**
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 81
diff changeset
89 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
90 */
80
682e20aa224f Pointers working now - big YAY
Anders Johnsen <skabet@gmail.com>
parents: 77
diff changeset
91 DPointer getPointerTo()
682e20aa224f Pointers working now - big YAY
Anders Johnsen <skabet@gmail.com>
parents: 77
diff changeset
92 {
682e20aa224f Pointers working now - big YAY
Anders Johnsen <skabet@gmail.com>
parents: 77
diff changeset
93 if(myPointer !is null)
682e20aa224f Pointers working now - big YAY
Anders Johnsen <skabet@gmail.com>
parents: 77
diff changeset
94 return myPointer;
682e20aa224f Pointers working now - big YAY
Anders Johnsen <skabet@gmail.com>
parents: 77
diff changeset
95 myPointer = new DPointer(this);
682e20aa224f Pointers working now - big YAY
Anders Johnsen <skabet@gmail.com>
parents: 77
diff changeset
96 return myPointer;
682e20aa224f Pointers working now - big YAY
Anders Johnsen <skabet@gmail.com>
parents: 77
diff changeset
97 }
83
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 81
diff changeset
98 private DPointer myPointer;
80
682e20aa224f Pointers working now - big YAY
Anders Johnsen <skabet@gmail.com>
parents: 77
diff changeset
99
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
100 /**
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
101 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
102 **/
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
103 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
104 {
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
105 /// 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
106 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
107 }
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
108
83
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 81
diff changeset
109 /**
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 81
diff changeset
110 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
111 */
81
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
112 DArray getAsArray(int size)
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
113 {
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
114 if(size in myArray)
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
115 return myArray[size];
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
116 myArray[size] = new DArray(this, size);
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
117 return myArray[size];
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
118 }
83
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 81
diff changeset
119 private DArray[int] myArray;
81
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
120
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
121 static DInteger
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
122 Bool,
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
123 Byte, UByte, Short, UShort,
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
124 Int, UInt, Long, ULong;
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
125
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
126 static DType Void;
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
127
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
128 static this()
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
129 {
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
130 Void = new DType("void");
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
131
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
132 Bool = new DInteger("bool", 1, false);
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
133 Byte = new DInteger("byte", 8, false);
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
134 UByte = new DInteger("ubyte", 8, true);
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
135 Short = new DInteger("short", 16, false);
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
136 UShort = new DInteger("ushort", 16, true);
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
137 Int = new DInteger("int", 32, false);
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
138 UInt = new DInteger("uint", 32, true);
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
139 Long = new DInteger("long", 64, false);
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
140 ULong = new DInteger("ulong", 64, true);
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
141 }
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
142 }
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
143
49
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
144 /**
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
145 Class to represent the built-in integer types, from byte to long.
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
146 */
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
147 class DInteger : DType
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
148 {
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
149 private static char[][DInteger] 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
150
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
151 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
152 {
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
153 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
154 [
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
155 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
156 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
157 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
158 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
159 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
160 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
161 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
162 Long : "l",
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
163 ULong : "m"
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
164 ];
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
165 }
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
166
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
167 this(char[] name, int bits, bool unsigned)
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
168 {
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
169 super(name, null);
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
170 this.bits = bits;
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
171 this.unsigned = unsigned;
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
172 }
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
173
39
1a7a308f75b2 Added some struct tests, and implemented a wrong struct assignment
Anders Halager <halager@gmail.com>
parents: 37
diff changeset
174 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
175
58
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
176 override bool hasImplicitConversionTo(DType that)
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
177 {
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
178 if (auto o = cast(DInteger)that)
68
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 64
diff changeset
179 return true;
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 64
diff changeset
180 // return this.bits >= o.bits;
58
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
181 return false;
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
182 }
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
183
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
184 override bool isInteger() { 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
185 override DInteger asInteger() { 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
186
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 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
188 {
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 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
190 }
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
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
192 int bits;
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
193 bool unsigned;
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
194 }
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
195
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
196 class DStruct : DType
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
197 {
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
198 this(Identifier id, DType actual = null)
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
199 {
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
200 super(id, actual);
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
201 }
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
202
39
1a7a308f75b2 Added some struct tests, and implemented a wrong struct assignment
Anders Halager <halager@gmail.com>
parents: 37
diff changeset
203 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
204
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
205 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
206 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
207
55
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
208 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
209 {
55
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
210 auto s = DStructMember(type, members.length);
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
211 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
212
55
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
213 bytes_total += type.byteSize();
49
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
214 }
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
215
55
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
216 int indexOf(char[] name)
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
217 {
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
218 if(name in members)
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
219 return members[name].index;
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
220
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
221 return -1;
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
222 }
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
223
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
224 DType typeOf(char[] name)
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
225 {
58
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
226 if (auto res = name in members)
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
227 return res.type;
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 55
diff changeset
228 return null;
55
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
229 }
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
230
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
231 DStructMember[char[]] members;
39
1a7a308f75b2 Added some struct tests, and implemented a wrong struct assignment
Anders Halager <halager@gmail.com>
parents: 37
diff changeset
232 private int bytes_total;
55
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
233
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
234 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
235 {
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
236 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
237 }
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
55
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
239 struct DStructMember
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
240 {
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
241 DType type;
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
242 int index;
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 49
diff changeset
243 }
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
244 }
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
245
72
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
246 class DArray : DType
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
247 {
81
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
248 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
249 {
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
250 super(id, actual);
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
251 this.arrayOf = arrayOf;
81
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
252 this.size = size;
72
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
253 }
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
254
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
255 override bool isArray() { return true; }
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
256 override DArray asArray() { return this; }
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
257
81
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
258 int byteSize() { return arrayOf.byteSize * size; }
72
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
259
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
260 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
261 {
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
262 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
263 }
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
264
72
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
265 DType arrayOf;
81
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
266 const int size;
72
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
267 }
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 68
diff changeset
268
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
269 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
270 {
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
271 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
272 {
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
273 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
274 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
275 }
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
276
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
277 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
278 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
279
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
280 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
281
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
282 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
283 {
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
284 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
285 }
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
286
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
287 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
288 }
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 72
diff changeset
289
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
290 class DFunction : DType
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
291 {
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
292 this(Identifier id, DType actual = null)
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
293 {
27
9031487e97d7 Various changes related to DType
Anders Halager <halager@gmail.com>
parents: 26
diff changeset
294 super(id, actual);
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
295 }
49
c7cde6af0095 Seperated the AST from LLVM
Anders Halager <halager@gmail.com>
parents: 39
diff changeset
296
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
297 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
298 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
299
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
300 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
301 {
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
302 char[] 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
303 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
304
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
305 foreach(param ; params)
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
306 res ~= "J" ~ param.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
307
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
308 res ~= "Z" ~ returnType.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
309
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
310 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
311 }
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
312
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
313 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
314 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
315 bool firstParamIsReturnValue = false;
26
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
316 }
b4dc2b2c0e38 Added a DType class
Anders Halager <halager@gmail.com>
parents:
diff changeset
317