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 _Common_AST_HH | |
9 | #define _Common_AST_HH | |
10 | ||
11 | ||
12 | #undef new | |
13 | #include <new> | |
14 | #include <set> | |
15 | #include <string> | |
16 | #include "../common/dbgnew.hh" | |
17 | ||
18 | #include "../common/ModuleVersion.hh" | |
19 | #include "CompilerError.hh" | |
20 | #include "Setting.hh" | |
21 | #include "Type.hh" | |
22 | #include "Value.hh" | |
23 | #include "vector.hh" | |
24 | ||
25 | namespace Ttcn { | |
26 | // not defined here | |
27 | class Template; | |
28 | class FormalParList; | |
29 | class ArrayDimensions; | |
30 | class Group; | |
31 | class Module; | |
32 | } // namespace Ttcn | |
33 | ||
34 | // not defined here | |
35 | class JSON_Tokenizer; | |
36 | ||
37 | /** | |
38 | * This namespace contains things used both in TTCN-3 | |
39 | * and ASN.1 compiler. | |
40 | */ | |
41 | namespace Common { | |
42 | ||
43 | /** | |
44 | * \defgroup AST AST | |
45 | * | |
46 | * These classes provide a unified interface for language entities | |
47 | * present both in TTCN and ASN. (Most of) the classes defined here | |
48 | * are abstract, and have a descendant (with the same name) in the | |
49 | * namespaces Asn and Ttcn. | |
50 | * | |
51 | * @{ | |
52 | */ | |
53 | ||
54 | class Identifier; | |
55 | class Modules; | |
56 | class Module; | |
57 | class Assignments; | |
58 | class Assignment; | |
59 | class TypeConv; | |
60 | class CodeGenHelper; | |
61 | ||
62 | enum visibility_t { | |
63 | NOCHANGE, /* for parser usage only; default visibility */ | |
64 | PUBLIC, /* public visibility */ | |
65 | PRIVATE, /* private visibility */ | |
66 | FRIEND /* friend visibility */ | |
67 | }; | |
68 | ||
69 | /** | |
70 | * Class for storing modules. | |
71 | * | |
72 | * This is, in effect, the "root" of the AST: there is only one instance | |
73 | * of this class (declared in main.cc). | |
74 | */ | |
75 | class Modules : public Node { | |
76 | private: | |
77 | /** Containers to store the modules. */ | |
78 | vector<Module> mods_v; | |
79 | map<string, Module> mods_m; | |
80 | ||
81 | /** Not implemented */ | |
82 | Modules(const Modules& p); | |
83 | Modules& operator=(const Modules& p); | |
84 | public: | |
85 | /** The default constructor. */ | |
86 | Modules(); | |
87 | /** The destructor. */ | |
88 | ~Modules(); | |
89 | /** Not implemented: generates FATAL_ERROR */ | |
90 | virtual Modules *clone() const; | |
91 | /** Adds a new module. The uniqueness of identifier is not checked. */ | |
92 | void add_mod(Module *p_mod); | |
93 | /** Returns whether a module with the given \a modid exists. */ | |
94 | bool has_mod_withId(const Identifier& p_modid); | |
95 | /** Gets the module with the given \a modid. Returns 0 if the | |
96 | * module does not exist (w/o error message). See also: | |
97 | * has_mod_withId */ | |
98 | Module* get_mod_byId(const Identifier& p_modid); | |
99 | /** Returns the referenced assignment or 0 if it does not exist. | |
100 | * Append an error message when necessary. */ | |
101 | Assignment* get_ass_bySRef(Ref_simple *p_ref); | |
102 | /** Checks the uniqueness of module identifiers. Prints an error | |
103 | * message if <tt>get_modid()</tt> returns the same for two | |
104 | * modules. */ | |
105 | void chk_uniq(); | |
106 | /** Performs the semantic analysis on modules of the ATS. | |
107 | * Generates error/warning messages when necessary */ | |
108 | void chk(); | |
109 | void write_checksums(); | |
110 | std::set<ModuleVersion> getVersionsWithProductNumber() const; | |
111 | private: | |
112 | /* Checks the ASN.1 top-level PDU types that were passed as command line | |
113 | * arguments */ | |
114 | void chk_top_level_pdus(); | |
115 | public: | |
116 | void generate_code(CodeGenHelper& cgh); | |
117 | void dump(unsigned level=1) const; | |
118 | ||
119 | /** Generates JSON schema segments for the types defined in the modules | |
120 | * and adds them to the JSON schema parameter. */ | |
121 | void add_types_to_json_schema(JSON_Tokenizer& json); | |
122 | ||
123 | /** Generates JSON schemas containing references to the types defined in the | |
124 | * modules. Information related to the types' JSON encoding and decoding | |
125 | * functions is also inserted after the references. */ | |
126 | void add_func_to_json_schema(map<Type*, JSON_Tokenizer>& json_refs); | |
127 | }; | |
128 | ||
129 | /** | |
130 | * Interface-class to represent a module. | |
131 | * | |
132 | * Abstract class because of clone() and a bunch of other methods. | |
133 | */ | |
134 | class Module : public Scope, public Location { | |
135 | public: | |
136 | enum moduletype_t { MOD_UNKNOWN, MOD_ASN, MOD_TTCN }; | |
137 | /** The map is used as a set. */ | |
138 | typedef map <Module*, void> module_set_t; | |
139 | protected: // *::Module need access | |
140 | moduletype_t moduletype; | |
141 | /** Module identifier ("module name") */ | |
142 | Identifier *modid; | |
143 | /** The \c Modules collection which contains this module. Not owned. */ | |
144 | /** Indicates whether the import list has been checked. */ | |
145 | bool imp_checked; | |
146 | /** Indicates whether to generate C++ code for the module. */ | |
147 | bool gen_code; | |
148 | /** Indicates whether the module has a checksum. */ | |
149 | bool has_checksum; | |
150 | /** Contains the set of modules that are visible through imports (i.e. the | |
151 | * module is imported either directly or indirectly by an imported module). | |
152 | * The set is complete if \a this is added to the set. */ | |
153 | module_set_t visible_mods; | |
154 | /** Contains the checksum (more correctly, a hash) of the module. | |
155 | * It is an MD5 hash of the TTCN source, computed by the lexer. */ | |
156 | unsigned char module_checksum[16]; | |
157 | ||
158 | /** @name Containers to store string literals. | |
159 | * @{ */ | |
160 | map<string, string> bs_literals; ///< bitstring values | |
161 | map<string, string> bp_literals; ///< bitstring patterns | |
162 | map<string, string> hs_literals; ///< hexstring values | |
163 | map<string, string> hp_literals; ///< hexstring patterns | |
164 | map<string, string> os_literals; ///< octetstring values | |
165 | map<string, string> op_literals; ///< octetstring patterns | |
166 | map<string, string> cs_literals; ///< charstring values | |
167 | map<ustring, string> us_literals; ///< universal charstring values | |
168 | map<string, string> pp_literals; ///< padding patterns (RAW codec) | |
169 | map<string, string> mp_literals; ///< matching patterns (TEXT codec) | |
170 | /** @} */ | |
171 | ||
172 | struct OID_literal { | |
173 | size_t nof_elems; | |
174 | string oid_id; | |
175 | }; | |
176 | map<string, OID_literal> oid_literals; | |
177 | ||
178 | /** Counter for the temporary identifiers */ | |
179 | size_t tmp_id_count; | |
180 | ||
181 | /** Control namespace and prefix. | |
182 | * The module owns these strings. */ | |
183 | char * control_ns; | |
184 | char * control_ns_prefix; | |
185 | ||
186 | /** Namespace declarations encountered (global for the entire program). | |
187 | * Keys are the prefixes. Values are the URIs. */ | |
188 | static map<string, const char> namespaces; | |
189 | ||
190 | /** The index of the replacement for the empty prefix, or -1. Returned by | |
191 | * \p get_ns_index if the empty prefix has indeed been replaced. */ | |
192 | static size_t replacement_for_empty_prefix; | |
193 | ||
194 | /** Namespace prefixes made up to avoid clashes. | |
195 | * Keys are the URIs (!), values are the prefixes. | |
196 | * (This is a reverse of a subset of the \p namespaces member). | |
197 | * This allows reuse of made-up prefixes if the same namespace URI | |
198 | * appears again. */ | |
199 | static map<string, const char> invented_prefixes; | |
200 | ||
201 | /** Indexes of the namespaces used by this module. | |
202 | * Written while Common::Type::generate_code_xerdescriptor() makes calls | |
203 | * to Common::Module::get_ns_index(). */ | |
204 | map<size_t, void> used_namespaces; | |
205 | ||
206 | /** How many different namespace URIs with empty prefix have been added */ | |
207 | static size_t default_namespace_attempt; | |
208 | ||
209 | /** Type conversions found in this module */ | |
210 | vector<TypeConv> type_conv_v; | |
211 | ||
212 | /** @name Module version fields | |
213 | * @{ */ | |
214 | char* product_number; | |
215 | unsigned int suffix; | |
216 | unsigned int release; | |
217 | unsigned int patch; | |
218 | unsigned int build; | |
219 | char* extra; | |
220 | /** @} */ | |
221 | ||
222 | friend class Ttcn::Module; | |
223 | ||
224 | /* * Value of GLOBAL-DEFAULTS MODIFIED-ENCODINGS */ | |
225 | //TODO: introduce bool modified_encodings; | |
226 | ||
227 | /** Generates code for all string literals that belong to the | |
228 | * module into \a target */ | |
229 | void generate_literals(output_struct *target); | |
230 | /** Generates the module level entry functions based on | |
231 | * \a output->functions. The resulting functions are placed into | |
232 | * \a output->source.function_bodies. | |
233 | * Also writes the control part, module checksum, XML namespaces, | |
234 | * module object to output->source.global_vars */ | |
235 | void generate_functions(output_struct *output); | |
236 | void generate_conversion_functions(output_struct *output); | |
237 | private: | |
238 | /** Copy constructor not implemented */ | |
239 | Module(const Module& p); | |
240 | /** Assignment disabled */ | |
241 | Module& operator=(const Module& p); | |
242 | ||
243 | /** Adds \a str to container \a literals with prefix \a prefix */ | |
244 | static string add_literal(map<string, string>& literals, const string& str, | |
245 | const char *prefix); | |
246 | ||
247 | void generate_bs_literals(char *&src, char *&hdr); | |
248 | void generate_bp_literals(char *&src, char *&hdr); | |
249 | void generate_hs_literals(char *&src, char *&hdr); | |
250 | void generate_hp_literals(char *&src, char *&hdr); | |
251 | void generate_os_literals(char *&src, char *&hdr); | |
252 | void generate_op_literals(char *&src, char *&hdr); | |
253 | void generate_cs_literals(char *&src, char *&hdr); | |
254 | void generate_us_literals(char *&src, char *&hdr); | |
255 | void generate_oid_literals(char *&src, char *&hdr); | |
256 | void generate_pp_literals(char *&src, char *&hdr); | |
257 | void generate_mp_literals(char *&src, char *&hdr); | |
258 | ||
259 | /** Clears the container \a literals */ | |
260 | static void clear_literals(map<string, string>& literals); | |
261 | ||
262 | public: | |
263 | Module(moduletype_t p_mt, Identifier *modid); | |
264 | virtual ~Module(); | |
265 | /** Adds type conversion \p p_conv to this module. */ | |
266 | void add_type_conv(TypeConv *p_conv); | |
267 | /** Checks if \p p_from_type and \p p_to_type types need conversion in | |
268 | * this module. */ | |
269 | bool needs_type_conv(Type *p_from_type, Type *p_to_type) const; | |
270 | /** Returns the module type (either TTCN-3 or ASN.1). */ | |
271 | moduletype_t get_moduletype() const {return moduletype;} | |
272 | /** Sets the flag to generate C++ code for this module. */ | |
273 | void set_gen_code() {gen_code = true;} | |
274 | /** Returns whether to generate C++ code for this module. */ | |
275 | bool get_gen_code() const {return gen_code;} | |
276 | /** Returns the module-identifier. */ | |
277 | const Identifier& get_modid() const {return *modid;} | |
278 | /** Gets the module scope. This function returns this scope or a | |
279 | * scope above this or 0 if neither is a Module. */ | |
280 | virtual Module* get_scope_mod() {return this;} | |
281 | virtual Module* get_scope_mod_gen() {return this;} | |
282 | virtual Assignments *get_asss() =0; | |
283 | virtual Common::Assignment* importAssignment( | |
284 | const Identifier& p_source_modid, const Identifier& p_id) const =0; | |
285 | /** Returns true if a symbol with identifier \a p_id is | |
286 | * exported. */ | |
287 | virtual bool exports_sym(const Identifier& p_id) =0; | |
288 | /** Returns whether the module has an imported definition/assignment with | |
289 | * identifier \a p_id */ | |
290 | virtual bool has_imported_ass_withId(const Identifier& p_id) = 0; | |
291 | /** Returns a pointer to the TTCN-3 special address type that is defined in | |
292 | * the TTCN-3 module. A NULL pointer is returned if the address type is not | |
293 | * defined in this module. This function is applicable to TTCN-3 modules | |
294 | * only (otherwise a FATAL_ERROR will occur). */ | |
295 | virtual Type *get_address_type(); | |
296 | /** Checks imports (and propagates the code generation | |
297 | * flags). */ | |
298 | virtual void chk_imp(ReferenceChain& refch, vector<Module>& moduleStack) = 0; | |
299 | /** Checks everything (imports, exports, assignments) */ | |
300 | virtual void chk() = 0; | |
301 | /** Checks this module and all imported modules in bottom-up order. | |
302 | * Argument \a checked_modules contains the list of modules that are | |
303 | * already checked */ | |
304 | void chk_recursive(module_set_t& checked_modules); | |
305 | /** Returns whether \a m is visible from \a this through imports. */ | |
306 | bool is_visible(Module *m); | |
307 | /** Extends \a p_visible_mods with the set of visible modules. It uses the | |
308 | * cache \a visible_mods if possible or calls \a get_imported_mods() | |
309 | * otherwise. */ | |
310 | void get_visible_mods(module_set_t& p_visible_mods); | |
311 | /** Walks through the import list and collects the imported modules into | |
312 | * \a p_imported_mods recursively. */ | |
313 | virtual void get_imported_mods(module_set_t& p_imported_mods) = 0; | |
314 | void write_checksum(); | |
315 | static char* get_product_identifier(const char* product_number, | |
316 | const unsigned int suffix, unsigned int release, unsigned int patch, | |
317 | unsigned int build, const char* extra=NULL); | |
318 | ModuleVersion getVersion() const; | |
319 | protected: // *::Module need access | |
320 | /** Collects the set of visible modules into \a visible_mods. */ | |
321 | void collect_visible_mods(); | |
322 | virtual void generate_code_internal(CodeGenHelper& cgh) = 0; | |
323 | public: | |
324 | /** Adds a string to the module's bitstring container. Returns a | |
325 | * string like "bs_xx", where xx is the index of the literal in | |
326 | * the container. */ | |
327 | inline string add_bitstring_literal(const string& bstr) | |
328 | { return add_literal(bs_literals, bstr, "bs_"); } | |
329 | inline string add_bitstring_pattern(const string& bpat) | |
330 | { return add_literal(bp_literals, bpat, "bp_"); } | |
331 | inline string add_hexstring_literal(const string& hstr) | |
332 | { return add_literal(hs_literals, hstr, "hs_"); } | |
333 | inline string add_hexstring_pattern(const string& hpat) | |
334 | { return add_literal(hp_literals, hpat, "hp_"); } | |
335 | inline string add_octetstring_literal(const string& ostr) | |
336 | { return add_literal(os_literals, ostr, "os_"); } | |
337 | inline string add_octetstring_pattern(const string& opat) | |
338 | { return add_literal(op_literals, opat, "op_"); } | |
339 | inline string add_charstring_literal(const string& cstr) | |
340 | { return add_literal(cs_literals, cstr, "cs_"); } | |
341 | inline string add_padding_pattern(const string& ppat) | |
342 | { return add_literal(pp_literals, ppat, "pp_"); } | |
343 | inline string add_matching_literal(const string& mpat) | |
344 | { return add_literal(mp_literals, mpat, "mp_"); } | |
345 | string add_ustring_literal(const ustring& ustr); | |
346 | string add_objid_literal(const string& oi_str, const size_t nof_elems); | |
347 | ||
348 | /** Sets the module checksum. Parameter \a checksum_ptr points to the | |
349 | * checksum to be set, which consists of \a checksum_len bytes. */ | |
350 | void set_checksum(size_t checksum_len, const unsigned char* checksum_ptr); | |
351 | ||
352 | /** Returns an identifier used for temporary C++ objects, | |
353 | * which is unique in the module */ | |
354 | string get_temporary_id(); | |
355 | ||
356 | /** Sets the control namespace and its prefix. | |
357 | * Any previous value is overwritten. | |
358 | * Takes ownership of the strings (must be allocated on the heap). */ | |
359 | void set_controlns(char *ns, char *prefix); | |
360 | ||
361 | /** Gets the control namespace components. | |
362 | * The caller must not free the strings. */ | |
363 | void get_controlns(const char * &ns, const char * &prefix); | |
364 | ||
365 | /** Adds a namespace to the list of known namespaces. | |
366 | * No effect if the namespace is already in the map. | |
367 | * @param new_uri namespace URI | |
368 | * @param new_prefix namespace prefix; NULL means "make up a prefix" | |
369 | * @note If \p new_prefix is empty and there is already a namespace with | |
370 | * an empty prefix, a new, non-empty prefix is invented for this URI; | |
371 | * in this case \p new_prefix is modified to contain the "made-up" value. | |
372 | * @note \p new_prefix \b MUST be expstring_t or allocated by Malloc | |
373 | * (add_namespace may call Free() on it) */ | |
374 | static void add_namespace(const char *new_uri, char * &new_prefix); | |
375 | ||
376 | /** Returns the number of XML namespaces */ | |
377 | static inline size_t get_nof_ns() | |
378 | { return namespaces.size(); } | |
379 | ||
380 | /** Return the index of the given namespace prefix in the list of namespaces. | |
381 | * If the namespace is not found, FATAL_ERROR occurs. | |
382 | * @note also records the index in the per-instance member used_namespaces | |
383 | * (which is why it cannot be static) */ | |
384 | size_t get_ns_index(const char *prefix); | |
385 | ||
386 | /** Rename the default namespace, but only if there were two or more | |
387 | * namespaces with empty prefixes */ | |
388 | static void rename_default_namespace(); | |
389 | ||
390 | /** Generates C++ code for the module */ | |
391 | void generate_code(CodeGenHelper& cgh); | |
392 | virtual void dump(unsigned level) const; | |
393 | ||
394 | /** Generates JSON schema segments for the types defined in the module | |
395 | * and adds them to the JSON schema parameter. */ | |
396 | virtual void add_types_to_json_schema(JSON_Tokenizer&) = 0; | |
397 | ||
398 | /** Generates JSON schemas containing references to the types that have JSON | |
399 | * encoding and/or decoding functions declared in the module. Information | |
400 | * related to these functions is also inserted after the references | |
401 | * (only for TTCN-3 modules). */ | |
402 | virtual void add_func_to_json_schema(map<Type*, JSON_Tokenizer>&) = 0; | |
403 | }; | |
404 | ||
405 | /** | |
406 | * Class to store assignments. | |
407 | */ | |
408 | class Assignments : public Scope { | |
409 | protected: // Ttcn::Definitions and Asn::Assignments need access | |
410 | ||
411 | Assignments(const Assignments& p): Scope(p) {} | |
412 | public: | |
413 | /** Constructor. */ | |
414 | Assignments() : Scope() {} | |
415 | ||
416 | virtual Assignments* get_scope_asss(); | |
417 | /** Returns the referenced assignment or 0 if it does not exist. | |
418 | * An error message is generated when necessary. */ | |
419 | virtual Assignment* get_ass_bySRef(Ref_simple *p_ref); | |
420 | /** Returns whether an assignment with id \a p_id exists; | |
421 | * either in the current scope or its parent (recursively). */ | |
422 | virtual bool has_ass_withId(const Identifier& p_id); | |
423 | /** Returns whether an assignment with id \a p_id exists. | |
424 | * Unlike \a has_ass_withId() this function does not look into the | |
425 | * parent scope. */ | |
426 | virtual bool has_local_ass_withId(const Identifier& p_id) = 0; | |
427 | /** Returns the locally defined assignment with the given id, | |
428 | * or NULL if it does not exist. */ | |
429 | virtual Assignment* get_local_ass_byId(const Identifier& p_id) = 0; | |
430 | /** Returns the number of assignments. Only the uniquely named | |
431 | * assignments are visible. */ | |
432 | virtual size_t get_nof_asss() = 0; | |
433 | /** Returns the assignment with the given index. Only the uniquely | |
434 | * named assignments are visible. */ | |
435 | virtual Assignment* get_ass_byIndex(size_t p_i) = 0; | |
436 | }; | |
437 | ||
438 | /** | |
439 | * Abstract class to represent different kinds of assignments. | |
440 | */ | |
441 | class Assignment : public Node, public Location { | |
442 | public: | |
443 | enum asstype_t { | |
444 | A_TYPE, /**< type */ | |
445 | A_CONST, /**< value (const) */ | |
446 | A_UNDEF, /**< undefined/undecided (ASN.1) */ | |
447 | A_ERROR, /**< erroneous; the kind cannot be deduced (ASN.1) */ | |
448 | A_OC, /**< information object class (ASN.1) */ | |
449 | A_OBJECT, /**< information object (ASN.1) */ | |
450 | A_OS, /**< information object set (ASN.1) */ | |
451 | A_VS, /**< value set (ASN.1) */ | |
452 | A_EXT_CONST, /**< external constant (TTCN-3) */ | |
453 | A_MODULEPAR, /**< module parameter (TTCN-3) */ | |
454 | A_MODULEPAR_TEMP, /**< template module parameter */ | |
455 | A_TEMPLATE, /**< template (TTCN-3) */ | |
456 | A_VAR, /**< variable (TTCN-3) */ | |
457 | A_VAR_TEMPLATE, /**< template variable, dynamic template (TTCN-3) */ | |
458 | A_TIMER, /**< timer (TTCN-3) */ | |
459 | A_PORT, /**< port (TTCN-3) */ | |
460 | A_FUNCTION, /**< function without return type (TTCN-3) */ | |
461 | A_FUNCTION_RVAL, /**< function that returns a value (TTCN-3) */ | |
462 | A_FUNCTION_RTEMP, /**< function that returns a template (TTCN-3) */ | |
463 | A_EXT_FUNCTION, /**< external function without return type (TTCN-3) */ | |
464 | A_EXT_FUNCTION_RVAL, /**< ext. func that returns a value (TTCN-3) */ | |
465 | A_EXT_FUNCTION_RTEMP, /**< ext. func that returns a template (TTCN-3) */ | |
466 | A_ALTSTEP, /**< altstep (TTCN-3) */ | |
467 | A_TESTCASE, /**< testcase (TTCN-3) */ | |
468 | A_PAR_VAL, /**< formal parameter (value) (TTCN-3) */ | |
469 | A_PAR_VAL_IN, /**< formal parameter (in value) (TTCN-3) */ | |
470 | A_PAR_VAL_OUT, /**< formal parameter (out value) (TTCN-3) */ | |
471 | A_PAR_VAL_INOUT, /**< formal parameter (inout value) (TTCN-3) */ | |
472 | A_PAR_TEMPL_IN, /**< formal parameter ([in] template) (TTCN-3) */ | |
473 | A_PAR_TEMPL_OUT, /**< formal parameter (out template) (TTCN-3) */ | |
474 | A_PAR_TEMPL_INOUT,/**< formal parameter (inout template) (TTCN-3) */ | |
475 | A_PAR_TIMER, /**< formal parameter (timer) (TTCN-3) */ | |
476 | A_PAR_PORT /**< formal parameter (port) (TTCN-3) */ | |
477 | }; | |
478 | protected: // Ttcn::Definition and Asn::Assignment need access | |
479 | asstype_t asstype; | |
480 | Identifier *id; /**< the name of the assignment */ | |
481 | Scope *my_scope; /**< the scope this assignment belongs to */ | |
482 | bool checked; | |
483 | visibility_t visibilitytype; | |
484 | ||
485 | /// Copy constructor disabled | |
486 | Assignment(const Assignment& p); | |
487 | /// Assignment disabled | |
488 | Assignment& operator=(const Assignment& p); | |
489 | virtual string get_genname() const = 0; | |
490 | public: | |
491 | Assignment(asstype_t p_asstype, Identifier *p_id); | |
492 | virtual ~Assignment(); | |
493 | virtual Assignment* clone() const =0; | |
494 | virtual asstype_t get_asstype() const; | |
495 | /** Returns the string representation of the assignment type */ | |
496 | const char *get_assname() const; | |
497 | /** Returns the description of the definition, which consists of the | |
498 | * assignment type and name. The name is either the fullname or only | |
499 | * the id. It depends on \a asstype and \a my_scope. */ | |
500 | string get_description(); | |
501 | /** Gets the id of the assignment. */ | |
502 | const Identifier& get_id() const {return *id;} | |
503 | /** Sets the internal pointer my_scope to \a p_scope. */ | |
504 | virtual void set_my_scope(Scope *p_scope); | |
505 | Scope* get_my_scope() const { return my_scope; } | |
506 | bool get_checked() const { return checked; } | |
507 | /** Return the visibility type of the assignment */ | |
508 | visibility_t get_visibility() const { return visibilitytype; } | |
509 | /** Returns whether the definition belongs to a TTCN-3 statement block | |
510 | * (i.e. it is defined in the body of a function, testcase, altstep or | |
511 | * control part). */ | |
512 | virtual bool is_local() const; | |
513 | /** @name Need to be overridden and implemented in derived classes. | |
514 | * Calling these methods causes a FATAL_ERROR. | |
515 | * | |
516 | * @{ | |
517 | */ | |
518 | virtual Setting* get_Setting(); | |
519 | virtual Type *get_Type(); | |
520 | virtual Value *get_Value(); | |
521 | virtual Ttcn::Template *get_Template(); | |
522 | virtual bool get_lazy_eval() const; | |
523 | /** @} */ | |
524 | /** Returns the formal parameter list of a TTCN-3 definition */ | |
525 | virtual Ttcn::FormalParList *get_FormalParList(); | |
526 | /** Returns the dimensions of TTCN-3 port and timer arrays or NULL | |
527 | * otherwise. */ | |
528 | virtual Ttcn::ArrayDimensions *get_Dimensions(); | |
529 | /** Returns the component type referred by the 'runs on' clause of a | |
530 | * TTCN-3 definition */ | |
531 | virtual Type *get_RunsOnType(); | |
532 | /** Semantic check */ | |
533 | virtual void chk() = 0; | |
534 | /** Checks whether the assignment has a valid TTCN-3 identifier, | |
535 | * i.e. is reachable from TTCN. */ | |
536 | void chk_ttcn_id(); | |
537 | /** Returns a string containing the C++ reference pointing to this | |
538 | * definition from the C++ equivalent of scope \a p_scope. The reference | |
539 | * is a simple identifier qualified with a namespace when necessary. | |
540 | * If \a p_prefix is not NULL it is inserted before the string returned by | |
541 | * function \a get_genname(). */ | |
542 | string get_genname_from_scope(Scope *p_scope, const char *p_prefix = 0); | |
543 | /** Returns the name of the C++ object in the RTE that contains the common | |
544 | * entry points for the module that the definition belongs to */ | |
545 | const char *get_module_object_name(); | |
546 | /** A stub function to avoid dynamic_cast's. It causes FATAL_ERROR unless | |
547 | * \a this is an `in' value or template parameter. The real implementation | |
548 | * is in class Ttcn::FormalPar. */ | |
549 | virtual void use_as_lvalue(const Location& p_loc); | |
550 | virtual void generate_code(output_struct *target, bool clean_up = false); | |
551 | virtual void generate_code(CodeGenHelper& cgh); // FIXME: this should be pure virtual | |
552 | virtual void dump(unsigned level) const; | |
553 | virtual Ttcn::Group* get_parent_group(); | |
554 | }; | |
555 | ||
556 | /** @} end of AST group */ | |
557 | ||
558 | } // namespace Common | |
559 | ||
560 | #endif // _Common_AST_HH |