Mercurial > projects > dang
annotate sema/ScopeBuilder.d @ 136:2be29b296081
Lots of changes:
- Parsing classes and interfaces
- Fixed some seg faults in sema
- Supporting "private" to some extend
- And a lot of other small fixes
| author | johnsen@johnsen-laptop |
|---|---|
| date | Fri, 11 Jul 2008 21:47:57 +0200 |
| parents | 9c48871eb816 |
| children | 6e6355fb5f0f |
| rev | line source |
|---|---|
|
92
771ac63898e2
A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot.
Anders Johnsen <skabet@gmail.com>
parents:
86
diff
changeset
|
1 module sema.ScopeBuilder; |
| 1 | 2 |
| 14 | 3 import tango.io.Stdout, |
| 4 tango.core.Array : find; | |
| 1 | 5 |
| 26 | 6 public |
| 129 | 7 import sema.Scope, |
| 8 sema.Symbol; | |
| 1 | 9 |
|
59
1d6f4ad38a91
Make most of the tests pass again
Anders Halager <halager@gmail.com>
parents:
56
diff
changeset
|
10 import sema.Visitor, |
|
1d6f4ad38a91
Make most of the tests pass again
Anders Halager <halager@gmail.com>
parents:
56
diff
changeset
|
11 basic.SmallArray; |
| 1 | 12 |
|
92
771ac63898e2
A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot.
Anders Johnsen <skabet@gmail.com>
parents:
86
diff
changeset
|
13 class ForwardReference : Visitor!(void) |
| 1 | 14 { |
|
101
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
15 override void visit(Module[] modules) |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
16 { |
|
133
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
17 (new TypeBuilder).visit(modules); |
|
101
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
18 this.modules = modules; |
| 129 | 19 inFunctionBodyStack.push(false); |
| 20 foreach (mod; modules) | |
| 21 { | |
| 22 current = mod; | |
| 23 foreach (decl; mod.decls) | |
| 24 visitDecl(decl); | |
| 25 } | |
|
101
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
26 } |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
27 |
|
53
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
28 override void visitFuncDecl(FuncDecl d) |
|
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
29 { |
| 129 | 30 |
|
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:
59
diff
changeset
|
31 visitExp(d.returnType); |
|
53
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
32 visitExp(d.identifier); |
|
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
33 foreach (arg; d.funcArgs) |
|
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
34 visitDecl(arg); |
| 129 | 35 |
| 36 inFunctionBodyStack.push(true); | |
| 37 | |
|
53
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
38 foreach (stmt; d.statements) |
|
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
39 visitStmt(stmt); |
|
59
1d6f4ad38a91
Make most of the tests pass again
Anders Halager <halager@gmail.com>
parents:
56
diff
changeset
|
40 |
| 129 | 41 inFunctionBodyStack.pop(); |
| 42 | |
| 136 | 43 d.sym = current.symbol.createMember( |
| 44 d.identifier.get, | |
| 45 d.type, | |
| 46 d.env.find(d.identifier)); | |
|
53
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
47 } |
|
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
48 |
|
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
49 override void visitVarDecl(VarDecl d) |
|
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
50 { |
|
82
06dda301ea61
Can declare outside functions and call c-functions
Anders Johnsen <skabet@gmail.com>
parents:
81
diff
changeset
|
51 visitExp(d.varType); |
|
86
29f486ccc203
Fixed a bug that made arrays as params fail big time
Anders Johnsen <skabet@gmail.com>
parents:
83
diff
changeset
|
52 visitExp(d.identifier); |
|
82
06dda301ea61
Can declare outside functions and call c-functions
Anders Johnsen <skabet@gmail.com>
parents:
81
diff
changeset
|
53 |
|
53
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
54 if (d.init) |
|
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
55 visitExp(d.init); |
|
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
56 |
| 129 | 57 DType t = typeOf(d.varType, d.env); |
| 136 | 58 d.sym = current.symbol.createAlias( |
| 59 d.identifier.get, | |
| 60 d.env.find(d.varType).sym, | |
| 61 d.env.find(d.identifier)); | |
| 62 d.sym.type = t; | |
|
53
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
63 } |
|
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
64 |
|
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
65 override void visitStructDecl(StructDecl s) |
|
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
66 { |
| 129 | 67 auto old = current.symbol; |
| 68 current.symbol = s.sym; | |
| 69 inFunctionBodyStack.push(false); | |
| 70 super.visitStructDecl(s); | |
| 71 inFunctionBodyStack.pop(); | |
| 72 current.symbol = old; | |
|
133
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
73 } |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
74 |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
75 DType typeOf(Identifier id, Scope sc) |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
76 { |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
77 if(auto i = cast(PointerIdentifier)id) |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
78 return (typeOf(i.pointerOf, sc)).getPointerTo(); |
| 136 | 79 else if(auto i = cast(StaticArrayIdentifier)id) |
| 80 return typeOf(i.arrayOf, sc).getAsStaticArray(i.size); | |
|
133
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
81 return sc.findType(id); |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
82 } |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
83 |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
84 Module[] modules; |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
85 Module current; |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
86 SmallArray!(bool) inFunctionBodyStack; |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
87 } |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
88 |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
89 class TypeBuilder : Visitor!(void) |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
90 { |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
91 override void visit(Module[] modules) |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
92 { |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
93 foreach (mod; modules) |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
94 { |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
95 current = mod; |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
96 foreach (decl; mod.decls) |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
97 visitDecl(decl); |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
98 } |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
99 } |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
100 |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
101 override void visitStructDecl(StructDecl s) |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
102 { |
|
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
103 auto st = s.env.findType(s.identifier).asStruct; |
| 136 | 104 s.sym = current.symbol.createMember( |
| 105 s.identifier.get, | |
| 106 st, | |
| 107 s.env.find(s.identifier)); | |
|
55
79cb0afafabe
Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents:
53
diff
changeset
|
108 |
|
107
189c049cbfcc
Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents:
103
diff
changeset
|
109 foreach (decl; s.decls) |
| 129 | 110 { |
| 111 DType type; | |
| 112 char[] name; | |
|
107
189c049cbfcc
Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents:
103
diff
changeset
|
113 if (auto varDecl = cast(VarDecl)decl) |
| 129 | 114 { |
| 115 type = typeOf(varDecl.varType, varDecl.env); | |
| 116 name = varDecl.identifier.get; | |
| 117 } | |
|
107
189c049cbfcc
Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents:
103
diff
changeset
|
118 else if (auto fd = cast(FuncDecl)decl) |
| 129 | 119 { |
| 120 type = fd.type; | |
| 121 name = fd.identifier.get; | |
| 122 } | |
| 123 st.addMember(type, name); | |
| 124 } | |
|
53
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
125 } |
|
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
126 |
|
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
127 DType typeOf(Identifier id, Scope sc) |
|
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
128 { |
|
77
13eea2c4e60d
Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents:
64
diff
changeset
|
129 if(auto i = cast(PointerIdentifier)id) |
|
83
9e90694f5da0
Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents:
82
diff
changeset
|
130 return (typeOf(i.pointerOf, sc)).getPointerTo(); |
| 136 | 131 else if(auto i = cast(StaticArrayIdentifier)id) |
| 132 return typeOf(i.arrayOf, sc).getAsStaticArray(i.size); | |
|
53
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
133 return sc.findType(id); |
|
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
134 } |
|
101
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
135 |
| 129 | 136 Module current; |
|
53
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
137 } |
|
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
138 |
|
133
9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
Anders Johnsen <skabet@gmail.com>
parents:
132
diff
changeset
|
139 |
| 129 | 140 /** |
| 141 Add scopes to everything, and add all identifiers that correspond to types. | |
| 142 Types/Symbols are added by ForwardReference. | |
| 143 **/ | |
|
53
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
144 class ScopeBuilder : Visitor!(void) |
|
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
145 { |
|
101
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
146 static ModuleHandler mHandle; |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
147 |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
148 static this() |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
149 { |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
150 mHandle = new ModuleHandler; |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
151 } |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
152 |
| 1 | 153 this() |
| 154 { | |
|
101
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
155 } |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
156 |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
157 override void visit(Module[] modules) |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
158 { |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
159 foreach(m ; modules) |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
160 visitModule(m); |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
161 |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
162 auto fr = new ForwardReference(); |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
163 |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
164 fr.visit(modules); |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
165 } |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
166 |
| 129 | 167 private void registerBasicTypeTo(char[] n, DType t, Scope sc, Module m) |
| 168 { | |
| 169 sc.types[n] = t; | |
| 170 auto id = new Identifier(n); | |
| 171 id.env = sc; | |
| 172 auto decl = new DummyDecl(); | |
| 136 | 173 auto sym = m.symbol.createMember(n, t, decl); |
| 174 sym.decl = decl; | |
| 129 | 175 decl.sym = sym; |
| 176 decl.env = sc; | |
| 177 sc.put(id, decl); | |
| 178 } | |
| 179 | |
|
101
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
180 override void visitModule(Module m) |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
181 { |
| 129 | 182 auto root = new Scope; |
| 183 table ~= root; | |
| 184 | |
| 185 m.symbol = new Symbol; | |
| 1 | 186 |
| 129 | 187 registerBasicTypeTo("void", DType.Void, root, m); |
| 188 registerBasicTypeTo("bool", DType.Bool, root, m); | |
| 189 registerBasicTypeTo("byte", DType.Byte, root, m); | |
| 190 registerBasicTypeTo("ubyte", DType.UByte, root, m); | |
| 191 registerBasicTypeTo("short", DType.Short, root, m); | |
| 192 registerBasicTypeTo("ushort", DType.UShort, root, m); | |
| 193 registerBasicTypeTo("int", DType.Int, root, m); | |
| 194 registerBasicTypeTo("uint", DType.UInt, root, m); | |
| 195 registerBasicTypeTo("long", DType.Long, root, m); | |
| 196 registerBasicTypeTo("ulong", DType.ULong, root, m); | |
| 197 | |
| 198 registerBasicTypeTo("char", DType.Char, root, m); | |
| 199 registerBasicTypeTo("wchar", DType.WChar, root, m); | |
| 200 registerBasicTypeTo("dchar", DType.DChar, root, m); | |
| 201 | |
| 202 registerBasicTypeTo("float", DType.Float, root, m); | |
| 203 registerBasicTypeTo("double", DType.Double, root, m); | |
| 204 registerBasicTypeTo("real", DType.Real, root, m); | |
|
119
c0b531362ca6
Non compileing commit. Work on floating points and casts
Anders Johnsen <skabet@gmail.com>
parents:
107
diff
changeset
|
205 |
|
99
857f0d530789
Imports and improved module statement
Anders Halager <halager@gmail.com>
parents:
94
diff
changeset
|
206 current().inModule = m; |
|
101
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
207 current().mHandle = mHandle; |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
208 mHandle.add(m); |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
209 m.env = current(); |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
210 super.visitModule(m); |
| 1 | 211 } |
| 212 | |
| 213 override void visitDecl(Decl d) | |
| 214 { | |
| 215 d.env = current(); | |
| 216 super.visitDecl(d); | |
| 217 } | |
| 218 | |
|
101
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
219 override void visitImportDecl(ImportDecl i) |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
220 { |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
221 i.env.imports ~= i; |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
222 super.visitImportDecl(i); |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
223 } |
|
fea8d61a2451
First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents:
99
diff
changeset
|
224 |
| 1 | 225 override void visitStmt(Stmt s) |
| 226 { | |
| 227 s.env = current(); | |
|
56
4ae365eff712
Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy...
Anders Johnsen <skabet@gmail.com>
parents:
55
diff
changeset
|
228 s.stmtIndex = s.env.stmtIndex; |
| 1 | 229 super.visitStmt(s); |
| 230 } | |
| 231 | |
| 232 override void visitExp(Exp e) | |
| 233 { | |
| 234 e.env = current(); | |
|
56
4ae365eff712
Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy...
Anders Johnsen <skabet@gmail.com>
parents:
55
diff
changeset
|
235 e.stmtIndex = e.env.stmtIndex; |
| 1 | 236 super.visitExp(e); |
| 237 } | |
| 238 | |
| 239 override void visitFuncDecl(FuncDecl d) | |
| 240 { | |
| 129 | 241 current().put(d.identifier, d); |
| 136 | 242 d.env = current(); |
|
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
|
243 auto sc = push(); |
|
53
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
244 |
|
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:
59
diff
changeset
|
245 visitExp(d.returnType); |
|
2
ae5bbe4e7fd6
Lots of stuff, here are the git comments:
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
246 visitExp(d.identifier); |
|
56
4ae365eff712
Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy...
Anders Johnsen <skabet@gmail.com>
parents:
55
diff
changeset
|
247 sc.parentFunction = d; |
|
2
ae5bbe4e7fd6
Lots of stuff, here are the git comments:
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
248 foreach (arg; d.funcArgs) |
|
ae5bbe4e7fd6
Lots of stuff, here are the git comments:
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
249 visitDecl(arg); |
|
ae5bbe4e7fd6
Lots of stuff, here are the git comments:
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
250 foreach (stmt; d.statements) |
|
56
4ae365eff712
Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy...
Anders Johnsen <skabet@gmail.com>
parents:
55
diff
changeset
|
251 { |
|
4ae365eff712
Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy...
Anders Johnsen <skabet@gmail.com>
parents:
55
diff
changeset
|
252 sc.currentStmtIndex++; |
|
2
ae5bbe4e7fd6
Lots of stuff, here are the git comments:
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
253 visitStmt(stmt); |
|
56
4ae365eff712
Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy...
Anders Johnsen <skabet@gmail.com>
parents:
55
diff
changeset
|
254 } |
| 14 | 255 pop(sc); |
| 1 | 256 } |
| 257 | |
| 258 override void visitVarDecl(VarDecl d) | |
| 259 { | |
| 24 | 260 if (d.init) |
| 261 visitExp(d.init); | |
| 262 | |
|
53
da551f90e03f
Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents:
45
diff
changeset
|
263 if (need_push > 0 && current().parentFunction !is null) { |
| 24 | 264 push(); |
| 265 --need_push; | |
| 266 } | |
| 267 | |
| 1 | 268 auto sc = current(); |
| 129 | 269 sc.put(d.identifier, d); |
| 24 | 270 d.env = sc; |
|
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:
59
diff
changeset
|
271 visitExp(d.varType); |
| 24 | 272 visitExp(d.identifier); |
| 1 | 273 } |
| 274 | |
| 22 | 275 override void visitStructDecl(StructDecl s) |
| 276 { | |
| 277 auto sc = current(); | |
| 129 | 278 sc.put(s.identifier, s); |
|
55
79cb0afafabe
Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents:
53
diff
changeset
|
279 s.env = sc; |
|
79cb0afafabe
Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents:
53
diff
changeset
|
280 auto type = new DStruct(s.identifier); |
| 129 | 281 |
|
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
|
282 sc.types[s.identifier.get] = type; |
|
55
79cb0afafabe
Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents:
53
diff
changeset
|
283 |
|
79cb0afafabe
Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents:
53
diff
changeset
|
284 sc = push(); |
| 136 | 285 Stdout(sc).newline; |
| 22 | 286 super.visitStructDecl(s); |
|
55
79cb0afafabe
Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents:
53
diff
changeset
|
287 pop(sc); |
| 22 | 288 } |
| 289 | |
| 14 | 290 override void visitDeclStmt(DeclStmt d) |
| 291 { | |
| 24 | 292 ++need_push; |
| 14 | 293 super.visitDeclStmt(d); |
| 294 } | |
| 24 | 295 private uint need_push = 0; |
| 14 | 296 |
|
11
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
297 override void visitIfStmt(IfStmt s) |
|
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
298 { |
|
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
299 s.env = current(); |
|
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
300 visitExp(s.cond); |
| 14 | 301 auto sc = push(); |
| 45 | 302 visitStmt(s.then_body); |
| 14 | 303 pop(sc); |
|
11
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
304 |
| 45 | 305 if (s.else_body !is null) |
| 306 { | |
| 307 sc = push(); | |
| 308 visitStmt(s.else_body); | |
| 309 pop(sc); | |
| 310 } | |
|
11
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
311 } |
|
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
312 |
|
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
313 override void visitWhileStmt(WhileStmt s) |
|
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
314 { |
|
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
315 s.env = current(); |
| 14 | 316 auto sc = push(); |
|
11
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
317 super.visitWhileStmt(s); |
| 14 | 318 pop(sc); |
|
11
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
319 } |
|
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
320 |
|
44
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
28
diff
changeset
|
321 override void visitCompoundStmt(CompoundStatement s) |
|
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
28
diff
changeset
|
322 { |
|
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
28
diff
changeset
|
323 s.env = current(); |
|
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
28
diff
changeset
|
324 auto sc = push(); |
|
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
28
diff
changeset
|
325 super.visitCompoundStmt(s); |
|
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
28
diff
changeset
|
326 pop(sc); |
|
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
28
diff
changeset
|
327 } |
|
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
28
diff
changeset
|
328 |
| 1 | 329 private: |
| 330 Scope[] table; | |
| 331 | |
| 14 | 332 Scope push() |
| 1 | 333 { |
| 14 | 334 auto sc = new Scope(current()); |
| 335 table ~= sc; | |
| 336 return sc; | |
| 1 | 337 } |
| 338 | |
| 14 | 339 Scope pop(Scope sc = null) |
| 1 | 340 { |
| 14 | 341 if (sc !is null) |
| 342 { | |
| 343 table.length = table.find(sc); | |
| 344 return sc; | |
| 345 } | |
| 346 | |
| 1 | 347 auto res = table[$ - 1]; |
| 348 table.length = table.length - 1; | |
| 349 return res; | |
| 350 } | |
| 351 | |
| 352 Scope current() | |
| 353 { | |
| 354 return table[$ - 1]; | |
| 355 } | |
| 356 } | |
| 357 |