]> git.localhorst.tv Git - l2e.git/blob - src/loader/ParsedSource.cpp
reordered type description creation to avoid reallocation
[l2e.git] / src / loader / ParsedSource.cpp
1 /*
2  * ParsedSource.cpp
3  *
4  *  Created on: Aug 26, 2012
5  *      Author: holy
6  */
7
8 #include "ParsedSource.h"
9
10 #include "utility.h"
11
12 #include <ostream>
13 #include <stdexcept>
14
15 using std::map;
16 using std::runtime_error;
17 using std::string;
18 using std::vector;
19
20 namespace loader {
21
22 ParsedSource::~ParsedSource() {
23         for (map<string, Declaration *>::const_iterator i(declarations.begin()), end(declarations.end()); i != end; ++i) {
24                 delete i->second;
25         }
26 }
27
28 void ParsedSource::AddDeclaration(Declaration *d) {
29         map<string, Declaration *>::iterator i(declarations.find(d->Identifier()));
30         if (i != declarations.end()) {
31                 if (d->TypeName() != i->second->TypeName()) {
32                         throw runtime_error("invalid redeclaration of " + i->second->TypeName() + " " + d->Identifier());
33                 }
34         } else {
35                 declarations.insert(std::make_pair(d->Identifier(), d));
36         }
37 }
38
39 void ParsedSource::AddDefinition(Definition *d) {
40         map<string, Definition *>::iterator i(definitions.find(d->Identifier()));
41         if (i != definitions.end()) {
42                 throw runtime_error("redefinition of " + i->second->TypeName() + " " + d->Identifier());
43         } else {
44                 definitions.insert(std::make_pair(d->Identifier(), d));
45         }
46 }
47
48 void ParsedSource::ExportDeclaration(Declaration *d) {
49         AddDeclaration(d);
50         exports.insert(d->Identifier());
51 }
52
53 void ParsedSource::ExportIdentifier(const std::string &i) {
54         if (declarations.count(i)) {
55                 exports.insert(i);
56         } else {
57                 throw runtime_error("cannot export undeclared identifier " + i);
58         }
59 }
60
61
62 bool ParsedSource::IsDeclared(const std::string &name) const {
63         return declarations.count(name);
64 }
65
66 Declaration &ParsedSource::GetDeclaration(const std::string &name) {
67         map<string, Declaration *>::const_iterator i(declarations.find(name));
68         if (i != declarations.end()) {
69                 return *i->second;
70         } else {
71                 throw runtime_error("undeclared identifier " + name);
72         }
73 }
74
75 const Declaration &ParsedSource::GetDeclaration(const std::string &name) const {
76         map<string, Declaration *>::const_iterator i(declarations.find(name));
77         if (i != declarations.end()) {
78                 return *i->second;
79         } else {
80                 throw runtime_error("undeclared identifier " + name);
81         }
82 }
83
84 bool ParsedSource::IsDefined(const std::string &name) const {
85         return definitions.count(name);
86 }
87
88 Definition &ParsedSource::GetDefinition(const std::string &name) {
89         map<string, Definition *>::const_iterator i(definitions.find(name));
90         if (i != definitions.end()) {
91                 return *i->second;
92         } else {
93                 string msg("undefined identifier " + name);
94                 map<string, Declaration *>::const_iterator i(declarations.find(name));
95                 if (i != declarations.end()) {
96                         msg += ", declared as " + i->second->TypeName();
97                 } else {
98                         msg += ", not declared";
99                 }
100                 throw runtime_error(msg);
101         }
102 }
103
104 const Definition &ParsedSource::GetDefinition(const std::string &name) const {
105         map<string, Definition *>::const_iterator i(definitions.find(name));
106         if (i != definitions.end()) {
107                 return *i->second;
108         } else {
109                 string msg("undefined identifier " + name);
110                 map<string, Declaration *>::const_iterator i(declarations.find(name));
111                 if (i != declarations.end()) {
112                         msg += ", declared as " + i->second->TypeName();
113                 } else {
114                         msg += ", not declared";
115                 }
116                 throw runtime_error(msg);
117         }
118 }
119
120 void ParsedSource::WriteHeader(std::ostream &out) const {
121         for (std::set<string>::const_iterator i(exports.begin()), end(exports.end()); i != end; ++i) {
122                 out << GetDeclaration(*i).TypeName() << ' ' << *i << std::endl;
123         }
124 }
125
126
127 Definition::~Definition() {
128         if (isLiteral) {
129                 delete reinterpret_cast<Literal *>(value);
130         } else {
131                 delete reinterpret_cast<PropertyList *>(value);
132         }
133 }
134
135 void Definition::SetValue(Literal *v) {
136         value = v;
137         isLiteral = true;
138 }
139
140 void Definition::SetValue(PropertyList *v) {
141         value = v;
142         isLiteral = false;
143 }
144
145 Literal *Definition::GetLiteral() {
146         if (isLiteral) {
147                 return reinterpret_cast<Literal *>(value);
148         } else {
149                 throw runtime_error("tried to access properties as literal");
150         }
151 }
152
153 const Literal *Definition::GetLiteral() const {
154         if (isLiteral) {
155                 return reinterpret_cast<Literal *>(value);
156         } else {
157                 throw runtime_error("tried to access properties as literal");
158         }
159 }
160
161 PropertyList *Definition::GetProperties() {
162         if (!isLiteral) {
163                 return reinterpret_cast<PropertyList *>(value);
164         } else {
165                 throw runtime_error("tried to access literal value as property list");
166         }
167 }
168
169 const PropertyList *Definition::GetProperties() const {
170         if (!isLiteral) {
171                 return reinterpret_cast<PropertyList *>(value);
172         } else if (GetLiteral()->GetType() == Literal::OBJECT) {
173                 return GetLiteral()->GetProperties();
174         } else {
175                 throw runtime_error("tried to access literal value as property list");
176         }
177 }
178
179
180 PropertyList::~PropertyList() {
181         for (map<string, Value *>::iterator i(props.begin()), end(props.end()); i != end; ++i) {
182                 delete i->second;
183         }
184 }
185
186
187 Literal::Literal(const vector<Value *> &v)
188 : props(0)
189 , values(v)
190 , i1(0), i2(0)
191 , i3(0), i4(0)
192 , b(false)
193 , type(ARRAY_VALUES) {
194
195 }
196
197 Literal::Literal(const std::vector<PropertyList *> &pls)
198 : props(0)
199 , propertyLists(pls)
200 , i1(0), i2(0)
201 , i3(0), i4(0)
202 , b(false)
203 , type(ARRAY_PROPS) {
204
205 }
206
207 Literal::Literal(bool b)
208 : props(0)
209 , i1(0), i2(0)
210 , i3(0), i4(0)
211 , b(b)
212 , type(BOOLEAN) {
213
214 }
215
216 Literal::Literal(int r, int g, int b, int a)
217 : props(0)
218 , i1(r), i2(g)
219 , i3(b), i4(a)
220 , b(false)
221 , type(COLOR) {
222
223 }
224
225 Literal::Literal(int number)
226 : props(0)
227 , i1(number), i2(0)
228 , i3(0), i4(0)
229 , b(false)
230 , type(NUMBER) {
231
232 }
233
234 Literal::Literal(const string &dir, const string &path)
235 : props(0)
236 , str(CatPath(dir, path))
237 , i1(0), i2(0)
238 , i3(0), i4(0)
239 , b(false)
240 , type(STRING) {
241
242 }
243
244 Literal::Literal(const string &str)
245 : props(0)
246 , str(str)
247 , i1(0), i2(0)
248 , i3(0), i4(0)
249 , b(false)
250 , type(STRING) {
251
252 }
253
254 Literal::Literal(int x, int y)
255 : props(0)
256 , i1(x), i2(y)
257 , i3(0), i4(0)
258 , b(false)
259 , type(VECTOR) {
260
261 }
262
263 Literal::Literal(const string &typeName, PropertyList *properties)
264 : props(properties)
265 , str(typeName)
266 , i1(0), i2(0)
267 , i3(0), i4(0)
268 , b(false)
269 , type(OBJECT) {
270
271 }
272
273 Literal::~Literal() {
274         switch (type) {
275                 case ARRAY_VALUES:
276                         for (vector<Value *>::const_iterator i(values.begin()), end(values.end()); i != end; ++i) {
277                                 delete *i;
278                         }
279                         break;
280                 case ARRAY_PROPS:
281                         for (vector<PropertyList *>::const_iterator i(propertyLists.begin()), end(propertyLists.end()); i != end; ++i) {
282                                 delete *i;
283                         }
284                         break;
285                 case OBJECT:
286                         delete props;
287                         break;
288                 default:
289                         break;
290         }
291 }
292
293
294 const vector<Value *> &Literal::GetValues() const {
295         if (type == ARRAY_VALUES) {
296                 return values;
297         } else {
298                 throw runtime_error("tried to access values of non-array literal");
299         }
300 }
301
302 const vector<PropertyList *> &Literal::GetPropertyLists() const {
303         if (type == ARRAY_PROPS) {
304                 return propertyLists;
305         } else {
306                 throw runtime_error("tried to access property lists of non-array literal");
307         }
308 }
309
310 bool Literal::GetBoolean() const {
311         if (type == BOOLEAN) {
312                 return b;
313         } else {
314                 throw runtime_error("tried to access boolean value of non-boolean literal");
315         }
316 }
317
318 int Literal::GetRed() const {
319         if (type == COLOR) {
320                 return i1;
321         } else {
322                 throw runtime_error("tried to access red component of non-color literal");
323         }
324 }
325
326 int Literal::GetGreen() const {
327         if (type == COLOR) {
328                 return i2;
329         } else {
330                 throw runtime_error("tried to access green component of non-color literal");
331         }
332 }
333
334 int Literal::GetBlue() const {
335         if (type == COLOR) {
336                 return i3;
337         } else {
338                 throw runtime_error("tried to access blue component of non-color literal");
339         }
340 }
341
342 int Literal::GetAlpha() const {
343         if (type == COLOR) {
344                 return i4;
345         } else {
346                 throw runtime_error("tried to access alpha component of non-color literal");
347         }
348 }
349
350 int Literal::GetNumber() const {
351         if (type == NUMBER) {
352                 return i1;
353         } else {
354                 throw runtime_error("tried to access numerical value of non-number literal");
355         }
356 }
357
358 const string &Literal::GetString() const {
359         if (type == STRING) {
360                 return str;
361         } else {
362                 throw runtime_error("tried to access string value of non-color literal");
363         }
364 }
365
366 int Literal::GetX() const {
367         if (type == VECTOR) {
368                 return i1;
369         } else {
370                 throw runtime_error("tried to access x component of non-vector literal");
371         }
372 }
373
374 int Literal::GetY() const {
375         if (type == VECTOR) {
376                 return i2;
377         } else {
378                 throw runtime_error("tried to access y component of non-vector literal");
379         }
380 }
381
382 const string &Literal::GetTypeName() const {
383         if (type == OBJECT) {
384                 return str;
385         } else {
386                 throw runtime_error("tried to access type name of non-object literal");
387         }
388 }
389
390 const PropertyList *Literal::GetProperties() const {
391         if (type == OBJECT) {
392                 return props;
393         } else {
394                 throw runtime_error("tried to access properties of non-object literal");
395         }
396 }
397
398
399 Value::~Value() {
400         if (isLiteral) {
401                 delete literal;
402         }
403 }
404
405 const Literal &Value::GetLiteral() const {
406         if (isLiteral) {
407                 return *literal;
408         } else {
409                 throw runtime_error("tried to access literal of identifier value");
410         }
411 }
412
413 const std::string &Value::GetIdentifier() const {
414         if (!isLiteral) {
415                 return identifier;
416         } else {
417                 throw runtime_error("tried to access identifier of literal value");
418         }
419 }
420
421 }
422
423
424 namespace std {
425
426 ostream &operator <<(ostream &out, const loader::ParsedSource &source) {
427         out << "parsed source file" << endl;
428         out << "declared objects: " << endl;
429         for (map<string, loader::Declaration *>::const_iterator i(source.Declarations().begin()), end(source.Declarations().end()); i != end; ++i) {
430                 out << " - " << i->first << " of type " << i->second->TypeName() << endl;
431         }
432         out << "defined objects: " << endl;
433         for (map<string, loader::Definition *>::const_iterator i(source.Definitions().begin()), end(source.Definitions().end()); i != end; ++i) {
434                 out << " - " << i->first << " of type " << i->second->TypeName() << endl;
435                 if (i->second->HasLiteralValue()) {
436                         out << "     literal value: " << *i->second->GetLiteral() << endl;
437                 }
438         }
439         out << "exported objects: " << endl;
440         for (set<string>::const_iterator i(source.Exports().begin()), end(source.Exports().end()); i != end; ++i) {
441                 out << " - " << *i << endl;
442         }
443         return out;
444 }
445
446 ostream &operator <<(ostream &out, const loader::Literal &l) {
447         switch (l.GetType()) {
448                 case loader::Literal::ARRAY_VALUES:
449                         out << "array of values";
450                         break;
451                 case loader::Literal::ARRAY_PROPS:
452                         out << "array of property lists";
453                         break;
454                 case loader::Literal::BOOLEAN:
455                         out << "boolean, " << (l.GetBoolean() ? "true" : "false");
456                         break;
457                 case loader::Literal::COLOR:
458                         out << "color, (" << l.GetRed() << ',' << l.GetGreen() << ',' << l.GetBlue() << ',' << l.GetAlpha() << ')';
459                         break;
460                 case loader::Literal::NUMBER:
461                         out << "number, " << l.GetNumber();
462                         break;
463                 case loader::Literal::PATH:
464                         out << "path, \"" << l.GetString() << '"';
465                         break;
466                 case loader::Literal::STRING:
467                         out << "string, \"" << l.GetString() << '"';
468                         break;
469                 case loader::Literal::VECTOR:
470                         out << "vector, <" << l.GetX() << ',' << l.GetY() << '>';
471                         break;
472                 case loader::Literal::OBJECT:
473                         out << "object of type " << l.GetTypeName();
474                         break;
475         }
476         return out;
477 }
478
479 }