Mercurial > projects > dang
annotate sema/ScopeBuilder.d @ 133:9c48871eb816
Now working with forward ref and structs in scope builder. New Symbol system should now be good to go!
author | Anders Johnsen <skabet@gmail.com> |
---|---|
date | Mon, 30 Jun 2008 16:43:40 +0200 |
parents | a101853eaae0 |
children | 2be29b296081 |
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 | |
43 d.sym = current.symbol.createMember(d.identifier.get, d.type); | |
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
|
44 } |
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
|
45 |
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
|
46 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
|
47 { |
82
06dda301ea61
Can declare outside functions and call c-functions
Anders Johnsen <skabet@gmail.com>
parents:
81
diff
changeset
|
48 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
|
49 visitExp(d.identifier); |
82
06dda301ea61
Can declare outside functions and call c-functions
Anders Johnsen <skabet@gmail.com>
parents:
81
diff
changeset
|
50 |
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
|
51 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
|
52 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
|
53 |
129 | 54 DType t = typeOf(d.varType, d.env); |
132
a101853eaae0
Better scope-building. Still an error with structs and forward ref though.
Anders Johnsen <skabet@gmail.com>
parents:
130
diff
changeset
|
55 d.sym = current.symbol.createAlias(d.identifier.get,d.env.find(d.varType).sym); |
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
|
56 } |
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
|
57 |
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
|
58 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
|
59 { |
129 | 60 auto old = current.symbol; |
61 current.symbol = s.sym; | |
62 inFunctionBodyStack.push(false); | |
63 super.visitStructDecl(s); | |
64 inFunctionBodyStack.pop(); | |
65 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
|
66 } |
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
|
67 |
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
|
68 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
|
69 { |
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
|
70 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
|
71 return (typeOf(i.pointerOf, sc)).getPointerTo(); |
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
|
72 else if(auto i = cast(ArrayIdentifier)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
|
73 return typeOf(i.arrayOf, sc).getAsArray(i.size); |
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 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
|
75 } |
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 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
|
78 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
|
79 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
|
80 } |
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 |
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 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
|
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 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
|
85 { |
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 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
|
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 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
|
89 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
|
90 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
|
91 } |
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 |
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 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
|
95 { |
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 auto st = s.env.findType(s.identifier).asStruct; |
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 s.sym = current.symbol.createMember(s.identifier.get, st); |
55
79cb0afafabe
Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents:
53
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 foreach (decl; s.decls) |
129 | 100 { |
101 DType type; | |
102 char[] name; | |
107
189c049cbfcc
Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents:
103
diff
changeset
|
103 if (auto varDecl = cast(VarDecl)decl) |
129 | 104 { |
105 type = typeOf(varDecl.varType, varDecl.env); | |
106 name = varDecl.identifier.get; | |
107 } | |
107
189c049cbfcc
Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents:
103
diff
changeset
|
108 else if (auto fd = cast(FuncDecl)decl) |
129 | 109 { |
110 type = fd.type; | |
111 name = fd.identifier.get; | |
112 } | |
113 st.addMember(type, name); | |
114 } | |
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
|
115 } |
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
|
116 |
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
|
117 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
|
118 { |
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
|
119 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
|
120 return (typeOf(i.pointerOf, sc)).getPointerTo(); |
129 | 121 else if(auto i = cast(ArrayIdentifier)id) |
83
9e90694f5da0
Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents:
82
diff
changeset
|
122 return typeOf(i.arrayOf, sc).getAsArray(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
|
123 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
|
124 } |
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
|
125 |
129 | 126 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
|
127 } |
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 |
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
|
129 |
129 | 130 /** |
131 Add scopes to everything, and add all identifiers that correspond to types. | |
132 Types/Symbols are added by ForwardReference. | |
133 **/ | |
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
|
134 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
|
135 { |
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
|
136 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
|
137 |
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
|
138 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
|
139 { |
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
|
140 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
|
141 } |
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
|
142 |
1 | 143 this() |
144 { | |
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
|
145 } |
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 |
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 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
|
148 { |
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 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
|
150 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
|
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 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
|
153 |
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
|
154 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
|
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 |
129 | 157 private void registerBasicTypeTo(char[] n, DType t, Scope sc, Module m) |
158 { | |
159 sc.types[n] = t; | |
160 auto sym = m.symbol.createMember(n, t); | |
161 auto id = new Identifier(n); | |
162 id.env = sc; | |
163 auto decl = new DummyDecl(); | |
164 decl.sym = sym; | |
165 decl.env = sc; | |
166 sc.put(id, decl); | |
167 } | |
168 | |
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
|
169 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
|
170 { |
129 | 171 auto root = new Scope; |
172 table ~= root; | |
173 | |
174 m.symbol = new Symbol; | |
1 | 175 |
129 | 176 registerBasicTypeTo("void", DType.Void, root, m); |
177 registerBasicTypeTo("bool", DType.Bool, root, m); | |
178 registerBasicTypeTo("byte", DType.Byte, root, m); | |
179 registerBasicTypeTo("ubyte", DType.UByte, root, m); | |
180 registerBasicTypeTo("short", DType.Short, root, m); | |
181 registerBasicTypeTo("ushort", DType.UShort, root, m); | |
182 registerBasicTypeTo("int", DType.Int, root, m); | |
183 registerBasicTypeTo("uint", DType.UInt, root, m); | |
184 registerBasicTypeTo("long", DType.Long, root, m); | |
185 registerBasicTypeTo("ulong", DType.ULong, root, m); | |
186 | |
187 registerBasicTypeTo("char", DType.Char, root, m); | |
188 registerBasicTypeTo("wchar", DType.WChar, root, m); | |
189 registerBasicTypeTo("dchar", DType.DChar, root, m); | |
190 | |
191 registerBasicTypeTo("float", DType.Float, root, m); | |
192 registerBasicTypeTo("double", DType.Double, root, m); | |
193 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
|
194 |
99
857f0d530789
Imports and improved module statement
Anders Halager <halager@gmail.com>
parents:
94
diff
changeset
|
195 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
|
196 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
|
197 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
|
198 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
|
199 super.visitModule(m); |
1 | 200 } |
201 | |
202 override void visitDecl(Decl d) | |
203 { | |
204 d.env = current(); | |
205 super.visitDecl(d); | |
206 } | |
207 | |
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
|
208 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
|
209 { |
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 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
|
211 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
|
212 } |
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
|
213 |
1 | 214 override void visitStmt(Stmt s) |
215 { | |
216 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
|
217 s.stmtIndex = s.env.stmtIndex; |
1 | 218 super.visitStmt(s); |
219 } | |
220 | |
221 override void visitExp(Exp e) | |
222 { | |
223 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
|
224 e.stmtIndex = e.env.stmtIndex; |
1 | 225 super.visitExp(e); |
226 } | |
227 | |
228 override void visitFuncDecl(FuncDecl d) | |
229 { | |
129 | 230 current().put(d.identifier, d); |
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
|
231 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
|
232 |
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
|
233 visitExp(d.returnType); |
2
ae5bbe4e7fd6
Lots of stuff, here are the git comments:
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
234 visitExp(d.identifier); |
1 | 235 d.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
|
236 sc.parentFunction = d; |
2
ae5bbe4e7fd6
Lots of stuff, here are the git comments:
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
237 foreach (arg; d.funcArgs) |
ae5bbe4e7fd6
Lots of stuff, here are the git comments:
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
238 visitDecl(arg); |
ae5bbe4e7fd6
Lots of stuff, here are the git comments:
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
239 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
|
240 { |
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
|
241 sc.currentStmtIndex++; |
2
ae5bbe4e7fd6
Lots of stuff, here are the git comments:
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
242 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
|
243 } |
14 | 244 pop(sc); |
1 | 245 } |
246 | |
247 override void visitVarDecl(VarDecl d) | |
248 { | |
24 | 249 if (d.init) |
250 visitExp(d.init); | |
251 | |
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
|
252 if (need_push > 0 && current().parentFunction !is null) { |
24 | 253 push(); |
254 --need_push; | |
255 } | |
256 | |
1 | 257 auto sc = current(); |
129 | 258 sc.put(d.identifier, d); |
24 | 259 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
|
260 visitExp(d.varType); |
24 | 261 visitExp(d.identifier); |
1 | 262 } |
263 | |
22 | 264 override void visitStructDecl(StructDecl s) |
265 { | |
266 auto sc = current(); | |
129 | 267 sc.put(s.identifier, s); |
55
79cb0afafabe
Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents:
53
diff
changeset
|
268 s.env = sc; |
79cb0afafabe
Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents:
53
diff
changeset
|
269 auto type = new DStruct(s.identifier); |
129 | 270 |
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
|
271 sc.types[s.identifier.get] = type; |
55
79cb0afafabe
Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents:
53
diff
changeset
|
272 |
79cb0afafabe
Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents:
53
diff
changeset
|
273 sc = push(); |
22 | 274 super.visitStructDecl(s); |
55
79cb0afafabe
Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents:
53
diff
changeset
|
275 pop(sc); |
22 | 276 } |
277 | |
14 | 278 override void visitDeclStmt(DeclStmt d) |
279 { | |
24 | 280 ++need_push; |
14 | 281 super.visitDeclStmt(d); |
282 } | |
24 | 283 private uint need_push = 0; |
14 | 284 |
11
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
285 override void visitIfStmt(IfStmt s) |
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
286 { |
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
287 s.env = current(); |
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
288 visitExp(s.cond); |
14 | 289 auto sc = push(); |
45 | 290 visitStmt(s.then_body); |
14 | 291 pop(sc); |
11
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
292 |
45 | 293 if (s.else_body !is null) |
294 { | |
295 sc = push(); | |
296 visitStmt(s.else_body); | |
297 pop(sc); | |
298 } | |
11
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
299 } |
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
300 |
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
301 override void visitWhileStmt(WhileStmt s) |
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
302 { |
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
303 s.env = current(); |
14 | 304 auto sc = push(); |
11
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
305 super.visitWhileStmt(s); |
14 | 306 pop(sc); |
11
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
307 } |
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
2
diff
changeset
|
308 |
44
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
28
diff
changeset
|
309 override void visitCompoundStmt(CompoundStatement s) |
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
28
diff
changeset
|
310 { |
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
28
diff
changeset
|
311 s.env = current(); |
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
28
diff
changeset
|
312 auto sc = push(); |
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
28
diff
changeset
|
313 super.visitCompoundStmt(s); |
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
28
diff
changeset
|
314 pop(sc); |
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
28
diff
changeset
|
315 } |
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
28
diff
changeset
|
316 |
1 | 317 private: |
318 Scope[] table; | |
319 | |
14 | 320 Scope push() |
1 | 321 { |
14 | 322 auto sc = new Scope(current()); |
323 table ~= sc; | |
324 return sc; | |
1 | 325 } |
326 | |
14 | 327 Scope pop(Scope sc = null) |
1 | 328 { |
14 | 329 if (sc !is null) |
330 { | |
331 table.length = table.find(sc); | |
332 return sc; | |
333 } | |
334 | |
1 | 335 auto res = table[$ - 1]; |
336 table.length = table.length - 1; | |
337 return res; | |
338 } | |
339 | |
340 Scope current() | |
341 { | |
342 return table[$ - 1]; | |
343 } | |
344 } | |
345 |