Mercurial > projects > dang
annotate ast/Stmt.d @ 57:43bb0a36b869 new_gen
Removed some debug output and updated for new llvm-bindings.
author | Anders Johnsen <skabet@gmail.com> |
---|---|
date | Mon, 28 Apr 2008 21:47:01 +0200 |
parents | 4ae365eff712 |
children | 1d6f4ad38a91 |
rev | line source |
---|---|
1 | 1 module ast.Stmt; |
2 | |
36
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
3 import Array = tango.core.Array, |
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:
46
diff
changeset
|
4 Integer = tango.text.convert.Integer, |
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:
46
diff
changeset
|
5 tango.io.Stdout; |
36
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
6 |
1 | 7 import ast.Exp, |
8 ast.Decl; | |
9 | |
36
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
10 import sema.SymbolTable, |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
11 misc.Error; |
1 | 12 |
13 enum StmtType | |
14 { | |
15 Stmt, | |
44
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
36
diff
changeset
|
16 Compound, |
1 | 17 Decl, |
18 Exp, | |
19 Return, | |
5
2c5a8f4c254a
Added very simple if support.
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
20 If, |
11
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
5
diff
changeset
|
21 While, |
36
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
22 Switch, |
1 | 23 } |
24 | |
25 class Stmt | |
26 { | |
27 this(StmtType stmtType = StmtType.Stmt) | |
28 { | |
29 this.stmtType = stmtType; | |
30 } | |
31 | |
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:
46
diff
changeset
|
32 void simplify() |
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:
46
diff
changeset
|
33 { |
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:
46
diff
changeset
|
34 } |
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:
46
diff
changeset
|
35 |
1 | 36 StmtType stmtType; |
37 Scope env; | |
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:
46
diff
changeset
|
38 int stmtIndex; |
1 | 39 } |
40 | |
44
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
36
diff
changeset
|
41 class CompoundStatement : Stmt |
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
36
diff
changeset
|
42 { |
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
36
diff
changeset
|
43 this(Stmt[] stmts) |
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
36
diff
changeset
|
44 { |
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
36
diff
changeset
|
45 super(StmtType.Compound); |
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
36
diff
changeset
|
46 this.statements = stmts; |
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
36
diff
changeset
|
47 } |
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
36
diff
changeset
|
48 |
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:
46
diff
changeset
|
49 void simplify() |
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:
46
diff
changeset
|
50 { |
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:
46
diff
changeset
|
51 foreach ( stmt ; statements ) |
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:
46
diff
changeset
|
52 stmt.simplify; |
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:
46
diff
changeset
|
53 } |
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:
46
diff
changeset
|
54 |
44
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
36
diff
changeset
|
55 Stmt[] statements; |
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
36
diff
changeset
|
56 } |
495188f9078e
Big update - Moving towards a better, more seperated parser
Anders Halager <halager@gmail.com>
parents:
36
diff
changeset
|
57 |
1 | 58 class ReturnStmt : Stmt |
59 { | |
60 this() | |
61 { | |
62 super(StmtType.Return); | |
63 } | |
64 | |
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:
46
diff
changeset
|
65 void simplify() |
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:
46
diff
changeset
|
66 { |
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:
46
diff
changeset
|
67 FuncDecl f = env.parentFunction; |
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:
46
diff
changeset
|
68 if(f.sret) |
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:
46
diff
changeset
|
69 { |
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:
46
diff
changeset
|
70 auto i = new Identifier("ret.val"); |
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:
46
diff
changeset
|
71 i.env = f.env; |
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:
46
diff
changeset
|
72 auto ass = new AssignExp(i, exp); |
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:
46
diff
changeset
|
73 ass.env = f.env; |
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:
46
diff
changeset
|
74 auto assStmt = new ExpStmt(ass); |
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:
46
diff
changeset
|
75 assStmt.env = f.env; |
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:
46
diff
changeset
|
76 |
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:
46
diff
changeset
|
77 Stmt[] stmts; |
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:
46
diff
changeset
|
78 foreach(index, stmt ; f.statements) |
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:
46
diff
changeset
|
79 { |
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:
46
diff
changeset
|
80 if(stmtIndex == index) |
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:
46
diff
changeset
|
81 stmts ~= assStmt; |
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:
46
diff
changeset
|
82 |
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:
46
diff
changeset
|
83 stmts ~= stmt; |
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:
46
diff
changeset
|
84 } |
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:
46
diff
changeset
|
85 f.statements = stmts; |
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:
46
diff
changeset
|
86 |
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:
46
diff
changeset
|
87 exp = null; |
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:
46
diff
changeset
|
88 } |
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:
46
diff
changeset
|
89 if(exp) |
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:
46
diff
changeset
|
90 exp.simplify; |
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:
46
diff
changeset
|
91 } |
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:
46
diff
changeset
|
92 |
1 | 93 public Exp exp; |
94 } | |
95 | |
96 class DeclStmt : Stmt | |
97 { | |
98 this(Decl decl) | |
99 { | |
100 super(StmtType.Decl); | |
101 this.decl = decl; | |
102 } | |
103 | |
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:
46
diff
changeset
|
104 void simplify() |
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:
46
diff
changeset
|
105 { |
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:
46
diff
changeset
|
106 decl.simplify; |
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:
46
diff
changeset
|
107 } |
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:
46
diff
changeset
|
108 |
1 | 109 public Decl decl; |
110 } | |
111 | |
112 class ExpStmt : Stmt | |
113 { | |
114 this(Exp exp) | |
115 { | |
116 super(StmtType.Exp); | |
117 this.exp = exp; | |
118 } | |
119 | |
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:
46
diff
changeset
|
120 void simplify() |
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:
46
diff
changeset
|
121 { |
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:
46
diff
changeset
|
122 exp = exp.simplify; |
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:
46
diff
changeset
|
123 } |
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:
46
diff
changeset
|
124 |
1 | 125 public Exp exp; |
126 } | |
5
2c5a8f4c254a
Added very simple if support.
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
127 |
2c5a8f4c254a
Added very simple if support.
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
128 class IfStmt : Stmt |
2c5a8f4c254a
Added very simple if support.
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
129 { |
45 | 130 this(Exp cond, Stmt then, Stmt el = null) |
5
2c5a8f4c254a
Added very simple if support.
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
131 { |
2c5a8f4c254a
Added very simple if support.
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
132 super(StmtType.If); |
2c5a8f4c254a
Added very simple if support.
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
133 this.cond = cond; |
11
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
5
diff
changeset
|
134 this.then_body = then; |
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
5
diff
changeset
|
135 this.else_body = el; |
5
2c5a8f4c254a
Added very simple if support.
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
136 } |
2c5a8f4c254a
Added very simple if support.
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
137 |
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:
46
diff
changeset
|
138 void simplify() |
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:
46
diff
changeset
|
139 { |
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:
46
diff
changeset
|
140 cond.simplify; |
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:
46
diff
changeset
|
141 then_body.simplify; |
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:
46
diff
changeset
|
142 else_body.simplify; |
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:
46
diff
changeset
|
143 } |
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:
46
diff
changeset
|
144 |
5
2c5a8f4c254a
Added very simple if support.
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
145 Exp cond; |
45 | 146 Stmt then_body; |
147 Stmt else_body; | |
5
2c5a8f4c254a
Added very simple if support.
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
148 } |
2c5a8f4c254a
Added very simple if support.
Anders Halager <halager@gmail.com>
parents:
1
diff
changeset
|
149 |
11
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
5
diff
changeset
|
150 class WhileStmt : Stmt |
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
5
diff
changeset
|
151 { |
46 | 152 this(Exp cond, Stmt stmts) |
11
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
5
diff
changeset
|
153 { |
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
5
diff
changeset
|
154 super(StmtType.While); |
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
5
diff
changeset
|
155 this.cond = cond; |
46 | 156 this.whileBody = stmts; |
11
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
5
diff
changeset
|
157 } |
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
5
diff
changeset
|
158 |
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:
46
diff
changeset
|
159 void simplify() |
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:
46
diff
changeset
|
160 { |
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:
46
diff
changeset
|
161 cond.simplify; |
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:
46
diff
changeset
|
162 whileBody.simplify; |
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:
46
diff
changeset
|
163 } |
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:
46
diff
changeset
|
164 |
11
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
5
diff
changeset
|
165 Exp cond; |
46 | 166 Stmt whileBody; |
11
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
5
diff
changeset
|
167 } |
642c6a998fd9
Support for while statements and fixed scope for if
Anders Halager <halager@gmail.com>
parents:
5
diff
changeset
|
168 |
36
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
169 class SwitchStmt : Stmt |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
170 { |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
171 this(Exp target) |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
172 { |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
173 super(StmtType.Switch); |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
174 cond = target; |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
175 } |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
176 |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
177 void addCase(IntegerLit[] values, Stmt[] stmts) |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
178 { |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
179 long[] new_values; |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
180 foreach (lit; values) |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
181 new_values ~= Integer.parse(lit.token.get); |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
182 cases ~= Case(values, stmts, new_values); |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
183 |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
184 // Make sure there is no two cases with the same value |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
185 // Does it belong here? |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
186 new_values = new_values.dup; |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
187 Array.sort(new_values); |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
188 long[] all_values = Array.unionOf(old_values, new_values); |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
189 if (all_values.length != old_values.length + new_values.length) |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
190 { |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
191 // overlap! |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
192 auto e = new Error( |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
193 "Can't have multiple cases with the same value." |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
194 " Values appearing in multiple cases: %0"); |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
195 e.loc(values[0].token.location); |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
196 |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
197 all_values = Array.intersectionOf(old_values, new_values); |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
198 char[][] vals; |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
199 foreach (val; all_values) |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
200 vals ~= Integer.toString(val); |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
201 e.arg(vals); |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
202 /* |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
203 foreach (c; cases) |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
204 foreach (i, v; c.values_converted) |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
205 if (Array.bsearch(all_values, v)) |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
206 e.tok(c.values[i].token); |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
207 */ |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
208 throw e; |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
209 } |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
210 old_values = all_values; |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
211 } |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
212 |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
213 void setDefault(Stmt[] stmts) |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
214 { |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
215 if (defaultBlock.length != 0) |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
216 throw new Error("Switch statements can't have multiple defaults"); |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
217 defaultBlock = stmts; |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
218 if (cases.length > 0) |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
219 cases[$ - 1].followedByDefault = true; |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
220 } |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
221 |
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:
46
diff
changeset
|
222 void simplify() |
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:
46
diff
changeset
|
223 { |
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:
46
diff
changeset
|
224 cond.simplify; |
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:
46
diff
changeset
|
225 foreach ( stmt ; defaultBlock ) |
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:
46
diff
changeset
|
226 stmt.simplify; |
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:
46
diff
changeset
|
227 foreach ( c ; cases ) |
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:
46
diff
changeset
|
228 foreach ( stmt ; c.stmts ) |
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:
46
diff
changeset
|
229 stmt.simplify; |
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:
46
diff
changeset
|
230 } |
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:
46
diff
changeset
|
231 |
36
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
232 Exp cond; |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
233 Case[] cases; |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
234 Stmt[] defaultBlock; |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
235 |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
236 struct Case |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
237 { |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
238 IntegerLit[] values; |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
239 Stmt[] stmts; |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
240 long[] values_converted; |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
241 bool followedByDefault = false; |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
242 } |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
243 |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
244 private long[] old_values; |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
245 } |
ce17bea8e9bd
Switch statements support
Anders Halager <halager@gmail.com>
parents:
11
diff
changeset
|
246 |