Commit | Line | Data |
---|---|---|
970ed795 EL |
1 | /////////////////////////////////////////////////////////////////////////////// |
2 | // Copyright (c) 2000-2014 Ericsson Telecom AB | |
3 | // All rights reserved. This program and the accompanying materials | |
4 | // are made available under the terms of the Eclipse Public License v1.0 | |
5 | // which accompanies this distribution, and is available at | |
6 | // http://www.eclipse.org/legal/epl-v10.html | |
7 | /////////////////////////////////////////////////////////////////////////////// | |
8 | #ifndef _Asn_AST_HH | |
9 | #define _Asn_AST_HH | |
10 | ||
11 | #include "../AST.hh" | |
12 | #include "../Int.hh" | |
13 | #include "Object0.hh" | |
14 | ||
15 | namespace Common { | |
16 | class CodeGenHelper; | |
17 | } | |
18 | ||
19 | /** | |
20 | * This namespace contains things related to ASN.1 compiler. | |
21 | */ | |
22 | namespace Asn { | |
23 | ||
24 | /** | |
25 | * \addtogroup AST | |
26 | * | |
27 | * @{ | |
28 | */ | |
29 | ||
30 | class Assignments; | |
31 | /** | |
32 | * This is used when parsing internal stuff (e.g., EXTERNAL, | |
33 | * EMBEDDED PDV, etc.). | |
34 | */ | |
35 | extern Assignments *parsed_assignments; | |
36 | ||
37 | using namespace Common; | |
38 | ||
39 | struct TagDefault; | |
40 | ||
41 | class Assignment; | |
42 | class Module; | |
43 | class Symbols; | |
44 | class Exports; | |
45 | class ImpMod; | |
46 | class Imports; | |
47 | class Ass_Undef; | |
48 | class Ass_T; | |
49 | class Ass_V; | |
50 | class Ass_VS; | |
51 | class Ass_OC; | |
52 | class Ass_O; | |
53 | class Ass_OS; | |
54 | ||
55 | /* not defined, only declared in this file */ | |
56 | ||
57 | class Block; | |
58 | class TokenBuf; | |
59 | class ValueSet; | |
60 | class ObjectClass; | |
61 | class Object; | |
62 | class ObjectSet; | |
63 | ||
64 | /** | |
65 | * Struct to represent default tagging. | |
66 | */ | |
67 | struct TagDefault { | |
68 | enum tagdef_t { | |
69 | EXPLICIT, /**< EXPLICIT TAGS */ | |
70 | IMPLICIT, /**< IMPLICIT TAGS */ | |
71 | AUTOMATIC /**< AUTOMATIC TAGS */ | |
72 | }; | |
73 | }; | |
74 | ||
75 | /** | |
76 | * Helper-class for parameterized assignments. | |
77 | */ | |
78 | class Ass_pard : public Node { | |
79 | private: | |
80 | Assignment *my_ass; // link to... | |
81 | Block *parlist_block; /**< parameter list */ | |
82 | /** if the block (parlist) is pre-parsed then it is deleted, and | |
83 | * the content is put into these vectors. */ | |
84 | vector<Identifier> dummyrefs; | |
85 | /** contains one tokenbuf for each parameter; e.g. for parameter | |
86 | * "INTEGER : i" it contains "i INTEGER ::=" */ | |
87 | vector<TokenBuf> governors; | |
88 | /** Instance counters: for each target module a separate counter is | |
89 | * maintained to get deterministic instance numbers in case of incremental | |
90 | * compilation. */ | |
91 | map<Common::Module*, size_t> inst_cnts; | |
92 | ||
93 | Ass_pard(const Ass_pard& p); | |
94 | Ass_pard& operator=(const Ass_pard& p); | |
95 | /** Split the formal parameterlist */ | |
96 | void preparse_pars(); | |
97 | public: | |
98 | Ass_pard(Block *p_parlist_block); | |
99 | virtual ~Ass_pard(); | |
100 | virtual Ass_pard* clone() const | |
101 | {return new Ass_pard(*this);} | |
102 | void set_my_ass(Assignment *p_my_ass) {my_ass=p_my_ass;} | |
103 | /** Returns the number of formal parameters. 0 means the parameter | |
104 | * list is erroneous. */ | |
105 | size_t get_nof_pars(); | |
106 | const Identifier& get_nth_dummyref(size_t i); | |
107 | TokenBuf* clone_nth_governor(size_t i); | |
108 | /** Returns the next instance number for target module \a p_mod */ | |
109 | size_t new_instnum(Common::Module *p_mod); | |
110 | }; | |
111 | ||
112 | /** | |
113 | * Abstract class to represent different kinds of assignments. | |
114 | */ | |
115 | class Assignment : public Common::Assignment { | |
116 | protected: // many classes derived | |
117 | Ass_pard *ass_pard; | |
118 | bool dontgen; | |
119 | ||
120 | Assignment(const Assignment& p); | |
121 | Assignment& operator=(const Assignment& p); | |
122 | virtual string get_genname() const; | |
123 | virtual Assignment* new_instance0(); | |
124 | public: | |
125 | Assignment(asstype_t p_asstype, Identifier *p_id, Ass_pard *p_ass_pard); | |
126 | virtual ~Assignment(); | |
127 | virtual Assignment* clone() const =0; | |
128 | virtual bool is_asstype(asstype_t p_asstype, ReferenceChain* refch=0); | |
129 | virtual void set_right_scope(Scope *p_scope) =0; | |
130 | void set_dontgen() {dontgen=true;} | |
131 | /** Returns 0 if assignment is not parameterized! */ | |
132 | Ass_pard* get_ass_pard() const { return ass_pard; } | |
133 | /** Returns 0 if this assignment is not parameterized! */ | |
134 | Assignment* new_instance(Common::Module *p_mod); | |
135 | virtual Type* get_Type(); | |
136 | virtual Value* get_Value(); | |
137 | virtual ValueSet* get_ValueSet(); | |
138 | virtual ObjectClass* get_ObjectClass(); | |
139 | virtual Object* get_Object(); | |
140 | virtual ObjectSet* get_ObjectSet(); | |
141 | virtual void chk(); | |
142 | virtual void dump(unsigned level) const; | |
143 | }; | |
144 | ||
145 | /** | |
146 | * Class to store assignments. It also contains the ASN-related | |
147 | * pre-defined (so-called "useful") stuff. | |
148 | */ | |
149 | class Assignments : public Common::Assignments { | |
150 | private: | |
151 | /** Special assignments. */ | |
152 | static Module *_spec_asss; | |
153 | public: | |
154 | static void create_spec_asss(); | |
155 | static void destroy_spec_asss(); | |
156 | /** Returns whether module \a p_mod is the module that contains the | |
157 | * special assignments */ | |
158 | static bool is_spec_asss(Common::Module *p_mod); | |
159 | private: | |
160 | /** The assignments. */ | |
161 | map<string, Assignment> asss_m; | |
162 | vector<Assignment> asss_v; | |
163 | /** Indicates whether the uniqueness of identifiers has been checked. */ | |
164 | bool checked; | |
165 | ||
166 | Assignments(const Assignments&); | |
167 | public: | |
168 | /** Constructor. */ | |
169 | Assignments() : Common::Assignments(), asss_m(), asss_v(), checked(false) | |
170 | { } | |
171 | /** Destructor. */ | |
172 | virtual ~Assignments(); | |
173 | virtual Assignments* clone() const; | |
174 | /** Sets the fullname. */ | |
175 | virtual void set_fullname(const string& p_fullname); | |
176 | /** Also looks into special assignments. */ | |
177 | virtual bool has_local_ass_withId(const Identifier& p_id); | |
178 | /** Also looks into special assignments. */ | |
179 | virtual Assignment* get_local_ass_byId(const Identifier& p_id); | |
180 | virtual size_t get_nof_asss(); | |
181 | virtual Common::Assignment* get_ass_byIndex(size_t p_i); | |
182 | /** Adds the Assignment. If \a checked flag is true and the id of the new | |
183 | * assignment is not unique it reports the error. */ | |
184 | void add_ass(Assignment *p_ass); | |
185 | /** Checks the uniqueness of identifiers. */ | |
186 | void chk_uniq(); | |
187 | /** Checks all assignments. */ | |
188 | void chk(); | |
189 | /** Sets the scope for the right side of assignments. Used in | |
190 | * parametrization. There is a strange situation that the left | |
191 | * and right sides of assignments can have different parent | |
192 | * scopes. */ | |
193 | void set_right_scope(Scope *p_scope); | |
194 | void generate_code(output_struct* target); | |
195 | void generate_code(CodeGenHelper& cgh); | |
196 | void dump(unsigned level) const; | |
197 | }; | |
198 | ||
199 | /** | |
200 | * Class to represent ASN-modules. | |
201 | */ | |
202 | class Module : public Common::Module { | |
203 | private: | |
204 | /** default tagging */ | |
205 | TagDefault::tagdef_t tagdef; | |
206 | /** extensibility implied */ | |
207 | bool extens_impl; | |
208 | /** exported stuff */ | |
209 | Exports *exp; | |
210 | /** imported stuff. */ | |
211 | Imports *imp; | |
212 | /** assignments of the module */ | |
213 | Assignments *asss; | |
214 | private: | |
215 | /** Copy constructor not implemented. */ | |
216 | Module(const Module&); | |
217 | /** Assignment not implemented */ | |
218 | Module& operator=(const Module&); | |
219 | public: | |
220 | Module(Identifier *p_modid, TagDefault::tagdef_t p_tagdef, | |
221 | bool p_extens_impl, Exports *p_exp, Imports *p_imp, | |
222 | Assignments *p_asss); | |
223 | virtual ~Module(); | |
224 | virtual Module* clone() const; | |
225 | virtual Common::Assignment* importAssignment( | |
226 | const Identifier& p_source_modid, const Identifier& p_id) const; | |
227 | /** Sets the fullname. */ | |
228 | virtual void set_fullname(const string& p_fullname); | |
229 | virtual Common::Assignments* get_scope_asss(); | |
230 | virtual bool has_imported_ass_withId(const Identifier& p_id); | |
231 | /** Returns the assignment referenced by p_ref. Appends an error | |
232 | * message an returns 0 if assignment is not found. */ | |
233 | virtual Common::Assignment* get_ass_bySRef(Ref_simple *p_ref); | |
234 | virtual Assignments *get_asss(); | |
235 | virtual bool exports_sym(const Identifier& p_id); | |
236 | virtual void chk_imp(ReferenceChain& refch, vector<Common::Module>& moduleStack); | |
237 | virtual void chk(); | |
238 | private: | |
239 | virtual void get_imported_mods(module_set_t& p_imported_mods); | |
240 | virtual bool has_circular_import(); | |
241 | virtual void generate_code_internal(CodeGenHelper& cgh); | |
242 | public: | |
243 | virtual void dump(unsigned level) const; | |
244 | void add_ass(Assignment *p_ass); | |
245 | TagDefault::tagdef_t get_tagdef() const { return tagdef; } | |
246 | ||
247 | /** Generates JSON schema segments for the types defined in the module | |
248 | * and adds them to the JSON schema parameter. */ | |
249 | virtual void add_types_to_json_schema(JSON_Tokenizer&); | |
250 | ||
251 | /** Does nothing. ASN.1 modules can't contain functions. */ | |
252 | virtual void add_func_to_json_schema(map<Type*, JSON_Tokenizer>&) {} | |
253 | }; | |
254 | ||
255 | /** | |
256 | * SymbolList. | |
257 | * Used only while parsing a module (and building the AST). | |
258 | */ | |
259 | class Symbols : public Node { | |
260 | friend class Exports; | |
261 | friend class ImpMod; | |
262 | friend class Imports; | |
263 | private: | |
264 | /** string => Identifier container */ | |
265 | typedef map<string, Identifier> syms_t; | |
266 | /** temporary container for symbols (no uniqueness checks) */ | |
267 | vector<Identifier> syms_v; | |
268 | /** the symbols */ | |
269 | syms_t syms_m; | |
270 | private: | |
271 | /** Copy constructor not implemented. */ | |
272 | Symbols(const Symbols&); | |
273 | /** Assignment not implemented. */ | |
274 | Symbols& operator=(const Symbols&); | |
275 | public: | |
276 | /** Default constructor. */ | |
277 | Symbols() : Node(), syms_v(), syms_m() { } | |
278 | /** Destructor. */ | |
279 | virtual ~Symbols(); | |
280 | /** Not implemented. */ | |
281 | virtual Symbols* clone() const; | |
282 | /** Adds \a p_id to the symlist. */ | |
283 | void add_sym(Identifier *p_id); | |
284 | /** Ensures uniqueness of identifiers in syms */ | |
285 | void chk_uniq(const Location& p_loc); | |
286 | }; | |
287 | ||
288 | /** | |
289 | * Exported symbols of a module. | |
290 | */ | |
291 | class Exports : public Node, public Location { | |
292 | private: | |
293 | bool checked; | |
294 | /** string => Identifier container */ | |
295 | /** my module */ | |
296 | Module *my_mod; | |
297 | /** exports all */ | |
298 | bool expall; | |
299 | /** exported symbols */ | |
300 | Symbols *symbols; | |
301 | private: | |
302 | /** Copy constructor not implemented. */ | |
303 | Exports(const Exports&); | |
304 | /** Assignment not implemented */ | |
305 | Exports& operator=(const Exports&); | |
306 | public: | |
307 | /** Constructor used when the module exports all. */ | |
308 | Exports(bool p_expall=false); | |
309 | /** Constructor used when there is a SymbolList. */ | |
310 | Exports(Symbols *p_symlist); | |
311 | /** Destructor. */ | |
312 | virtual ~Exports(); | |
313 | /** Not implemented. */ | |
314 | virtual Exports* clone() const; | |
315 | /** Sets the internal pointer to its module. */ | |
316 | void set_my_mod(Module *p_mod) {my_mod=p_mod;} | |
317 | /** Returns true if a symbol with identifier \a p_id is | |
318 | * exported. */ | |
319 | bool exports_sym(const Identifier& p_id); | |
320 | /** Checks whether the exported symbols are defined in the module. */ | |
321 | void chk_exp(); | |
322 | }; | |
323 | ||
324 | /** | |
325 | * Imported module. | |
326 | */ | |
327 | class ImpMod : public Node, public Location { | |
328 | friend class Imports; | |
329 | private: | |
330 | /** my module */ | |
331 | Module *my_mod; | |
332 | /** identifier of imported module */ | |
333 | Identifier *modid; | |
334 | /** pointer to the imported module */ | |
335 | Common::Module *mod; | |
336 | /** imported symbols */ | |
337 | Symbols *symbols; | |
338 | private: | |
339 | /** Copy constructor not implemented. */ | |
340 | ImpMod(const ImpMod&); | |
341 | /** Assignment not implemented */ | |
342 | ImpMod& operator=(const ImpMod&); | |
343 | public: | |
344 | /** Constructor. */ | |
345 | ImpMod(Identifier *p_modid, Symbols *p_symlist); | |
346 | /** Destructor. */ | |
347 | virtual ~ImpMod(); | |
348 | /** Not implemented. */ | |
349 | virtual ImpMod* clone() const; | |
350 | /** Sets the internal pointer to its module. */ | |
351 | void set_my_mod(Module *p_mod) {my_mod=p_mod;} | |
352 | /** Gets the module id of imported module. */ | |
353 | const Identifier& get_modid() const {return *modid;} | |
354 | void set_mod(Common::Module *p_mod) { mod = p_mod; } | |
355 | Common::Module *get_mod() const { return mod; } | |
356 | bool has_sym(const Identifier& p_id) const; | |
357 | /** Checks whether the imported symbols exist. Appends error | |
358 | * messages when needed. */ | |
359 | void chk_imp(ReferenceChain& refch); | |
360 | void generate_code(output_struct *target); | |
361 | }; | |
362 | ||
363 | /** | |
364 | * Imported modules. | |
365 | */ | |
366 | class Imports : public Node, public Location { | |
367 | friend class Module; | |
368 | private: | |
369 | /** my module */ | |
370 | Module *my_mod; | |
371 | /** imported modules */ | |
372 | vector<Asn::ImpMod> impmods_v; | |
373 | map<string, Asn::ImpMod> impmods; | |
374 | /** these symbols are mentioned only once in IMPORTS */ | |
375 | map<string, Common::Module> impsyms_1; | |
376 | /** these symbols are mentioned more than once in IMPORTS. This | |
377 | * map is used as a set. */ | |
378 | map<string, void> impsyms_m; | |
379 | /** Indicates whether the import list has been checked. */ | |
380 | bool checked; | |
381 | /** Indicates whether the owner module is a part of a circular import | |
382 | * chain. */ | |
383 | bool is_circular; | |
384 | private: | |
385 | /** Copy constructor not implemented. */ | |
386 | Imports(const Imports&); | |
387 | /** Assignment not implemented */ | |
388 | Imports& operator=(const Imports&); | |
389 | public: | |
390 | /** Constructor. */ | |
391 | Imports() | |
392 | : Node(), my_mod(0), impmods_v(), impmods(), impsyms_1(), impsyms_m(), | |
393 | checked(false), is_circular(false) {} | |
394 | /** Destructor. */ | |
395 | virtual ~Imports(); | |
396 | /** Not implemented. */ | |
397 | virtual Imports* clone() const; | |
398 | /** Adds the ImpMod. If a module with that id already exists, | |
399 | * throws an Error_AST_uniq exception. */ | |
400 | void add_impmod(ImpMod *p_impmod); | |
401 | /** Sets the internal pointer my_mod to \a p_mod. */ | |
402 | void set_my_mod(Module *p_mod); | |
403 | /** Recursive check. Checks whether the modules with the id exist, | |
404 | * then checks that ImpMod. */ | |
405 | void chk_imp(ReferenceChain& refch); | |
406 | /** Returns whether symbols from module with identifier \a p_id | |
407 | * are imported. */ | |
408 | bool has_impmod_withId(const Identifier& p_id) const | |
409 | { return impmods.has_key(p_id.get_name()); } | |
410 | const ImpMod *get_impmod_byId(const Identifier& p_id) const | |
411 | { return impmods[p_id.get_name()]; } | |
412 | /** Returns whether a symbol with identifier \a p_id is imported from one | |
413 | * or more modules */ | |
414 | bool has_impsym_withId(const Identifier& p_id) const; | |
415 | void get_imported_mods(Module::module_set_t& p_imported_mods); | |
416 | bool get_is_circular() const { return is_circular; } | |
417 | void generate_code(output_struct *target); | |
418 | }; | |
419 | ||
420 | /** | |
421 | * Undefined assignment. | |
422 | */ | |
423 | class Ass_Undef : public Assignment { | |
424 | private: | |
425 | Node *left, *right; | |
426 | Scope *right_scope; | |
427 | /** the classified assignment */ | |
428 | Assignment *ass; | |
429 | ||
430 | void classify_ass(ReferenceChain *refch=0); | |
431 | virtual Assignment* new_instance0(); | |
432 | Ass_Undef(const Ass_Undef& p); | |
433 | /// Assignment disabled | |
434 | Ass_Undef& operator=(const Ass_Undef& p); | |
435 | public: | |
436 | Ass_Undef(Identifier *p_id, Ass_pard *p_ass_pard, | |
437 | Node *p_left, Node *p_right); | |
438 | virtual ~Ass_Undef(); | |
439 | virtual Assignment* clone() const; | |
440 | virtual asstype_t get_asstype() const; | |
441 | virtual void set_fullname(const string& p_fullname); | |
442 | virtual void set_my_scope(Scope *p_scope); | |
443 | virtual void set_right_scope(Scope *p_scope); | |
444 | virtual bool is_asstype(asstype_t p_asstype, ReferenceChain* refch=0); | |
445 | virtual Setting* get_Setting(); | |
446 | virtual Type* get_Type(); | |
447 | virtual Value* get_Value(); | |
448 | virtual ValueSet* get_ValueSet(); | |
449 | virtual ObjectClass* get_ObjectClass(); | |
450 | virtual Object* get_Object(); | |
451 | virtual ObjectSet* get_ObjectSet(); | |
452 | virtual void chk(); | |
453 | virtual void generate_code(output_struct *target, bool clean_up = false); | |
454 | virtual void generate_code(CodeGenHelper& cgh); | |
455 | virtual void dump(unsigned level) const; | |
456 | private: | |
457 | bool _error_if_pard(); | |
458 | }; | |
459 | ||
460 | /** | |
461 | * Erroneous assignment. | |
462 | */ | |
463 | class Ass_Error : public Assignment { | |
464 | private: | |
465 | Setting *setting_error; | |
466 | Type *type_error; | |
467 | Value *value_error; | |
468 | ||
469 | /// Copy constructor not implemented (even though clone works) | |
470 | Ass_Error(const Ass_Error& p); | |
471 | /// Assignment disabled | |
472 | Ass_Error& operator=(const Ass_Error& p); | |
473 | virtual Assignment* new_instance0(); | |
474 | public: | |
475 | Ass_Error(Identifier *p_id, Ass_pard *p_ass_pard); | |
476 | virtual ~Ass_Error(); | |
477 | virtual Assignment* clone() const; | |
478 | virtual bool is_asstype(asstype_t p_asstype, ReferenceChain* refch=0); | |
479 | virtual void set_right_scope(Scope *) {} | |
480 | virtual Setting* get_Setting(); | |
481 | virtual Type* get_Type(); | |
482 | virtual Value* get_Value(); | |
483 | virtual ValueSet* get_ValueSet(); | |
484 | virtual ObjectClass* get_ObjectClass(); | |
485 | virtual Object* get_Object(); | |
486 | virtual ObjectSet* get_ObjectSet(); | |
487 | virtual void chk(); | |
488 | virtual void dump(unsigned level) const; | |
489 | }; | |
490 | ||
491 | /** | |
492 | * Type assignment. | |
493 | */ | |
494 | class Ass_T : public Assignment { | |
495 | private: | |
496 | Type *right; | |
497 | ||
498 | virtual Assignment* new_instance0(); | |
499 | /// Copy constructor for clone() only | |
500 | Ass_T(const Ass_T& p); | |
501 | /// Assignment disabled | |
502 | Ass_T& operator=(const Ass_T& p); | |
503 | public: | |
504 | Ass_T(Identifier *p_id, Ass_pard *p_ass_pard, Type *p_right); | |
505 | virtual ~Ass_T(); | |
506 | virtual Ass_T* clone() const | |
507 | {return new Ass_T(*this);} | |
508 | virtual void set_fullname(const string& p_fullname); | |
509 | virtual void set_my_scope(Scope *p_scope); | |
510 | virtual void set_right_scope(Scope *p_scope); | |
511 | virtual Setting* get_Setting() {return get_Type();} | |
512 | virtual Type* get_Type(); | |
513 | virtual void chk(); | |
514 | virtual void generate_code(output_struct *target, bool clean_up = false); | |
515 | virtual void generate_code(CodeGenHelper& cgh); | |
516 | virtual void dump(unsigned level) const; | |
517 | }; | |
518 | ||
519 | /** | |
520 | * Value assignment. | |
521 | */ | |
522 | class Ass_V : public Assignment { | |
523 | private: | |
524 | Type *left; | |
525 | Value *right; | |
526 | ||
527 | virtual Assignment* new_instance0(); | |
528 | /// Copy constructor for clone() only | |
529 | Ass_V(const Ass_V& p); | |
530 | /// Assignment disabled | |
531 | Ass_V& operator=(const Ass_V& p); | |
532 | public: | |
533 | Ass_V(Identifier *p_id, Ass_pard *p_ass_pard, | |
534 | Type *p_left, Value *p_right); | |
535 | virtual ~Ass_V(); | |
536 | virtual Ass_V* clone() const | |
537 | {return new Ass_V(*this);} | |
538 | virtual void set_fullname(const string& p_fullname); | |
539 | virtual void set_my_scope(Scope *p_scope); | |
540 | virtual void set_right_scope(Scope *p_scope); | |
541 | virtual Setting* get_Setting() {return get_Value();} | |
542 | virtual Type* get_Type(); | |
543 | virtual Value* get_Value(); | |
544 | virtual void chk(); | |
545 | virtual void generate_code(output_struct *target, bool clean_up = false); | |
546 | virtual void generate_code(CodeGenHelper& cgh); | |
547 | virtual void dump(unsigned level) const; | |
548 | }; | |
549 | ||
550 | /** | |
551 | * ValueSet assignment. | |
552 | */ | |
553 | class Ass_VS : public Assignment { | |
554 | private: | |
555 | Type *left; | |
556 | Block *right; | |
557 | Scope *right_scope; | |
558 | ||
559 | virtual Assignment* new_instance0(); | |
560 | /// Copy constructor for clone() only | |
561 | Ass_VS(const Ass_VS& p); | |
562 | /// Assignment disabled | |
563 | Ass_VS& operator=(const Ass_VS& p); | |
564 | public: | |
565 | Ass_VS(Identifier *p_id, Ass_pard *p_ass_pard, | |
566 | Type *p_left, Block *p_right); | |
567 | virtual ~Ass_VS(); | |
568 | virtual Ass_VS* clone() const | |
569 | {return new Ass_VS(*this);} | |
570 | virtual void set_fullname(const string& p_fullname); | |
571 | virtual void set_my_scope(Scope *p_scope); | |
572 | virtual void set_right_scope(Scope *p_scope); | |
573 | virtual Setting* get_Setting() {return get_Type();} | |
574 | virtual Type* get_Type(); | |
575 | virtual void chk(); | |
576 | virtual void generate_code(output_struct *target, bool clean_up = false); | |
577 | virtual void generate_code(CodeGenHelper& cgh); | |
578 | virtual void dump(unsigned level) const; | |
579 | }; | |
580 | ||
581 | /** | |
582 | * ObjectClass assignment. | |
583 | */ | |
584 | class Ass_OC : public Assignment { | |
585 | private: | |
586 | ObjectClass *right; | |
587 | ||
588 | virtual Assignment* new_instance0(); | |
589 | /// Copy constructor for clone() only | |
590 | Ass_OC(const Ass_OC& p); | |
591 | /// Assignment disabled | |
592 | Ass_OC& operator=(const Ass_OC& p); | |
593 | public: | |
594 | Ass_OC(Identifier *p_id, Ass_pard *p_ass_pard, ObjectClass *p_right); | |
595 | virtual ~Ass_OC(); | |
596 | virtual Ass_OC* clone() const | |
597 | {return new Ass_OC(*this);} | |
598 | virtual void set_fullname(const string& p_fullname); | |
599 | virtual void set_my_scope(Scope *p_scope); | |
600 | virtual void set_right_scope(Scope *p_scope); | |
601 | virtual void chk(); | |
602 | virtual Setting* get_Setting() {return get_ObjectClass();} | |
603 | virtual ObjectClass* get_ObjectClass(); | |
604 | virtual void generate_code(output_struct *target, bool clean_up = false); | |
605 | virtual void generate_code(CodeGenHelper& cgh); | |
606 | virtual void dump(unsigned level) const; | |
607 | }; | |
608 | ||
609 | /** | |
610 | * Object assignment. | |
611 | */ | |
612 | class Ass_O : public Assignment { | |
613 | private: | |
614 | ObjectClass *left; | |
615 | Object *right; | |
616 | ||
617 | virtual Assignment* new_instance0(); | |
618 | /// Copy constructor for clone() only | |
619 | Ass_O(const Ass_O& p); | |
620 | /// Assignment disabled | |
621 | Ass_O& operator=(const Ass_O& p); | |
622 | public: | |
623 | Ass_O(Identifier *p_id, Ass_pard *p_ass_pard, | |
624 | ObjectClass *p_left, Object *p_right); | |
625 | virtual ~Ass_O(); | |
626 | virtual Ass_O* clone() const | |
627 | {return new Ass_O(*this);} | |
628 | virtual void set_fullname(const string& p_fullname); | |
629 | virtual void set_my_scope(Scope *p_scope); | |
630 | virtual void set_right_scope(Scope *p_scope); | |
631 | virtual Setting* get_Setting() {return get_Object();} | |
632 | //virtual ObjectClass* get_ObjectClass(); | |
633 | virtual Object* get_Object(); | |
634 | virtual void chk(); | |
635 | virtual void generate_code(output_struct *target, bool clean_up = false); | |
636 | virtual void generate_code(CodeGenHelper& cgh); | |
637 | virtual void dump(unsigned level) const; | |
638 | }; | |
639 | ||
640 | /** | |
641 | * ObjectSet assignment. | |
642 | */ | |
643 | class Ass_OS : public Assignment { | |
644 | private: | |
645 | ObjectClass *left; | |
646 | ObjectSet *right; | |
647 | ||
648 | virtual Assignment* new_instance0(); | |
649 | /// Copy constructor for clone() only | |
650 | Ass_OS(const Ass_OS& p); | |
651 | /// Assignment disabled | |
652 | Ass_OS& operator=(const Ass_OS& p); | |
653 | public: | |
654 | Ass_OS(Identifier *p_id, Ass_pard *p_ass_pard, | |
655 | ObjectClass *p_left, ObjectSet *p_right); | |
656 | virtual ~Ass_OS(); | |
657 | virtual Ass_OS* clone() const | |
658 | {return new Ass_OS(*this);} | |
659 | virtual void set_fullname(const string& p_fullname); | |
660 | virtual void set_my_scope(Scope *p_scope); | |
661 | virtual void set_right_scope(Scope *p_scope); | |
662 | virtual Setting* get_Setting() {return get_ObjectSet();} | |
663 | //virtual ObjectClass* get_ObjectClass(); | |
664 | virtual ObjectSet* get_ObjectSet(); | |
665 | virtual void chk(); | |
666 | virtual void generate_code(output_struct *target, bool clean_up = false); | |
667 | virtual void generate_code(CodeGenHelper& cgh); | |
668 | virtual void dump(unsigned level) const; | |
669 | }; | |
670 | ||
671 | /** @} end of AST group */ | |
672 | ||
673 | } // namespace Asn | |
674 | ||
675 | #endif // _Asn_AST_HH |