Commit | Line | Data |
---|---|---|
d44e3c4f | 1 | /****************************************************************************** |
2 | * Copyright (c) 2000-2016 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 | * Contributors: | |
9 | * Balasko, Jeno | |
10 | * Baranyi, Botond | |
11 | * Beres, Szabolcs | |
12 | * Cserveni, Akos | |
13 | * Forstner, Matyas | |
14 | * Gecse, Roland | |
15 | * Kovacs, Ferenc | |
16 | * Raduly, Csaba | |
17 | * Szabo, Janos Zoltan – initial implementation | |
18 | * | |
19 | ******************************************************************************/ | |
970ed795 EL |
20 | #ifndef _Common_Valuestuff_HH |
21 | #define _Common_Valuestuff_HH | |
22 | ||
23 | #include "Setting.hh" | |
24 | #include "Int.hh" | |
25 | #include "ttcn3/AST_ttcn3.hh" | |
26 | ||
27 | class ustring; | |
28 | ||
29 | namespace Asn { | |
30 | class Block; | |
31 | } | |
32 | ||
33 | namespace Common { | |
34 | ||
35 | // not defined here | |
36 | class Value; | |
37 | using Asn::Block; | |
38 | ||
39 | /** | |
40 | * \addtogroup AST_Value | |
41 | * | |
42 | * @{ | |
43 | */ | |
44 | ||
45 | /** | |
46 | * Class to represent an IndexedValue. | |
47 | */ | |
48 | class IndexedValue : public Node, public Location { | |
49 | private: | |
50 | Ttcn::FieldOrArrayRef *index; | |
51 | Value *value; | |
52 | IndexedValue(const IndexedValue& p); | |
53 | public: | |
54 | IndexedValue(Ttcn::FieldOrArrayRef *p_index, Value *p_value); | |
55 | virtual ~IndexedValue(); | |
56 | virtual IndexedValue* clone() const; | |
57 | virtual void set_fullname(const string& p_fullname); | |
58 | virtual void set_my_scope(Scope *p_scope); | |
59 | void set_code_section(GovernedSimple::code_section_t p_code_section); | |
60 | inline Value *get_index() const { return index->get_val(); } | |
61 | inline Value *get_value() const { return value; } | |
62 | Value *steal_value(); | |
63 | virtual void dump(unsigned level) const; | |
64 | virtual bool is_unfoldable(ReferenceChain *refch=0, | |
65 | Type::expected_value_t exp_val=Type::EXPECTED_DYNAMIC_VALUE); | |
66 | ||
67 | }; | |
68 | ||
69 | /** | |
70 | * Class to represent ValueList. | |
71 | */ | |
72 | class Values : public Node { | |
73 | private: | |
74 | bool indexed; | |
75 | union { | |
76 | vector<Value> *vs; | |
77 | vector<IndexedValue> *ivs; | |
78 | }; | |
79 | Values(const Values& p); | |
80 | public: | |
81 | Values(bool p_indexed = false); | |
82 | virtual ~Values(); | |
83 | virtual Values *clone() const; | |
84 | virtual void set_fullname(const string& p_fullname); | |
85 | virtual void set_my_scope(Scope *p_scope); | |
86 | void add_v(Value *p_v); | |
87 | void add_iv(IndexedValue *p_iv); | |
88 | size_t get_nof_vs() const; | |
89 | size_t get_nof_ivs() const; | |
90 | Value *get_v_byIndex(size_t p_i) const; | |
91 | IndexedValue *get_iv_byIndex(size_t p_i) const; | |
92 | Value *steal_v_byIndex(size_t p_i); | |
93 | IndexedValue *steal_iv_byIndex(size_t p_i); | |
94 | virtual void dump(unsigned p_level) const; | |
95 | inline bool is_indexed() const { return indexed; } | |
96 | }; | |
97 | ||
98 | /** | |
99 | * Class to represent a NamedValue. | |
100 | */ | |
101 | class NamedValue : public Node, public Location { | |
102 | private: | |
103 | Identifier *name; | |
104 | Value *value; | |
105 | NamedValue(const NamedValue& p); | |
106 | public: | |
107 | NamedValue(Identifier *p_name, Value *p_value); | |
108 | virtual ~NamedValue(); | |
109 | virtual NamedValue* clone() const; | |
110 | virtual void set_fullname(const string& p_fullname); | |
111 | virtual void set_my_scope(Scope *p_scope); | |
112 | const Identifier& get_name() const { return *name; } | |
113 | Value *get_value() const { return value; } | |
114 | Value *steal_value(); | |
115 | virtual void dump(unsigned level) const; | |
116 | }; | |
117 | ||
118 | /** | |
119 | * Class to represent NamedValueList. | |
120 | */ | |
121 | class NamedValues : public Node { | |
122 | private: | |
123 | /** named values */ | |
124 | vector<NamedValue> nvs_v; | |
125 | /** Stores the first occurence of NamedValue with id. The string | |
126 | * parameter refers to the id of the nv. */ | |
127 | map<string, NamedValue> nvs_m; | |
128 | bool checked; | |
129 | NamedValues(const NamedValues& p); | |
130 | public: | |
131 | NamedValues() : Node(), checked(false) { } | |
132 | virtual ~NamedValues(); | |
133 | virtual NamedValues *clone() const; | |
134 | virtual void set_fullname(const string& p_fullname); | |
135 | virtual void set_my_scope(Scope *p_scope); | |
136 | void add_nv(NamedValue *p_nv); | |
137 | /** Returns the vector's size! */ | |
138 | size_t get_nof_nvs() const { return nvs_v.size(); } | |
139 | NamedValue *get_nv_byIndex(const size_t p_i) const { return nvs_v[p_i]; } | |
140 | bool has_nv_withName(const Identifier& p_name); | |
141 | NamedValue *get_nv_byName(const Identifier& p_name); | |
142 | void chk_dupl_id(bool report_errors = true); | |
143 | virtual void dump(unsigned level) const; | |
144 | }; | |
145 | ||
146 | /** | |
147 | * Object identifier component. | |
148 | */ | |
149 | class OID_comp : public Node, public Location { | |
150 | public: | |
151 | /** Which form was used. */ | |
152 | enum formtype_t { | |
153 | NAMEFORM, /**< NameForm */ | |
154 | NUMBERFORM, /**< NumberForm */ | |
155 | NAMEANDNUMBERFORM, /**< NameAndNumberForm */ | |
156 | DEFDVALUE, /**< DefinedValue */ | |
157 | VARIABLE /**< Variable */ | |
158 | }; | |
159 | /** Which state the checking is in. */ | |
160 | enum oidstate_t { | |
161 | START, /**< at the beginning */ | |
162 | ITU, /**< after itu-t */ | |
163 | ISO, /**< after iso */ | |
164 | JOINT, /**< after joint-iso-itu-t */ | |
165 | ITU_REC, /**< after itu-t recommendation */ | |
166 | LATER /**< later anywhere */ | |
167 | }; | |
168 | private: | |
169 | struct nameform_t { | |
170 | const char *name; | |
171 | unsigned int value; | |
172 | }; | |
173 | static const nameform_t names_root[], names_itu[], names_iso[], | |
174 | names_joint[]; | |
175 | private: | |
176 | formtype_t formtype; | |
177 | /** OID, ROID or INTEGER */ | |
178 | Value *defdval; | |
179 | /** maybe a reference to an INTEGER or R/OID (if NAMEFORM) */ | |
180 | Identifier *name; | |
181 | /** Integer (or reference to an integer) */ | |
182 | Value *number; | |
183 | /** Integer variable (cannot be calculated in compile-time) */ | |
184 | Value *var; | |
185 | ||
186 | OID_comp(const OID_comp& p); | |
187 | public: | |
188 | OID_comp(Identifier *p_name, Value *p_number); | |
189 | OID_comp(Value *p_defdval); | |
190 | virtual ~OID_comp(); | |
191 | virtual OID_comp *clone() const; | |
192 | /** Checking function for OID components */ | |
193 | void chk_OID(ReferenceChain& refch, Value *parent, size_t index, | |
194 | oidstate_t& state); | |
195 | /** checking function for ROID components */ | |
196 | void chk_ROID(ReferenceChain& refch, size_t index); | |
197 | /** Returns whether the component contains any error. */ | |
198 | bool has_error(); | |
199 | /** Appends the integer value of number or the components of the referenced | |
200 | * OID/ROID value to \a comps. */ | |
201 | void get_comps(vector<string>& comps); | |
202 | ||
203 | /** Returns true, if the component's value is unknown at compile-time */ | |
204 | bool is_variable(); | |
205 | private: | |
206 | /** Detects whether the identifier in \a name is a valid name form in | |
207 | * state \a state. If yes the equivalent non-negative numeric value is | |
208 | * returned and \a state is updated. Otherwise -1 is returned and | |
209 | * \a state remains unchanged. */ | |
210 | Int detect_nameform(oidstate_t& state); | |
211 | /** Checks the defined value in \a defdval in an OID component and | |
212 | * updates \a state accordingly. */ | |
213 | void chk_defdvalue_OID(ReferenceChain& refch, oidstate_t& state); | |
214 | /** Checks the NumberForm (or the number part of NameAndNumberForm) in an | |
215 | * OID component and updates \a state accordingly. */ | |
216 | void chk_numberform_OID(oidstate_t& state); | |
217 | /** Checks the NameAndNumberForm: checks the \a number, updates \a state | |
218 | * and verifies whether the name is in accordance with \a name and the | |
219 | * initial \a state. */ | |
220 | void chk_nameandnumberform(oidstate_t& state); | |
221 | /** Returns whether \a p_name is a correct name for \a p_number according | |
222 | * to the table \a p_names. */ | |
223 | static bool is_valid_name_for_number(const string& p_name, | |
224 | const Int& p_number, const nameform_t *p_names); | |
225 | /** Returns the expected name(s) for number \a p_number according to table | |
226 | * \a p_names. Flag \a p_asn1 indicates the the ASN.1 or TTCN-3 notation | |
227 | * shall be used in the identifiers. */ | |
228 | static string get_expected_name_for_number(const Int& p_number, | |
229 | bool p_asn1, const nameform_t *p_names); | |
230 | /** Checks the defined value in \a defdval in a ROID component. */ | |
231 | void chk_defdvalue_ROID(ReferenceChain& refch); | |
232 | /** Checks the NumberForm (or the number part of NameAndNumberForm) in a | |
233 | * ROID component. */ | |
234 | void chk_numberform_ROID(); | |
235 | public: | |
236 | virtual void set_fullname(const string& p_fullname); | |
237 | void set_my_scope(Scope *p_scope); | |
238 | /** Appends the string representation of the OID component to \a str. */ | |
239 | void append_stringRepr(string& str) const; | |
240 | }; | |
241 | ||
242 | /** | |
243 | * Universal charstring element. | |
244 | */ | |
245 | class CharsDefn : public Node, public Location { | |
246 | public: | |
247 | enum selector_t { | |
248 | CD_CSTRING, | |
249 | CD_QUADRUPLE, | |
250 | CD_TUPLE, | |
251 | CD_VALUE, | |
252 | CD_BLOCK | |
253 | } selector; | |
254 | bool checked; | |
255 | private: | |
256 | union { | |
257 | string *str; /**< cstring */ | |
258 | struct {Int g, p, r, c;} quadruple; /**< quadruple */ | |
259 | struct {Int c, r;} tuple; /**< tuple */ | |
260 | Value *val; /**< defined val => referenced val */ | |
261 | Block *block; /**< quadruple or tuple block */ | |
262 | } u; | |
263 | ||
264 | CharsDefn(const CharsDefn& p); | |
265 | public: | |
266 | /** ctor for cstr */ | |
267 | CharsDefn(string *p_str); | |
268 | /** ctor for val */ | |
269 | CharsDefn(Value *p_val); | |
270 | /** ctor for quadruple */ | |
271 | CharsDefn(Int p_g, Int p_p, Int p_r, Int p_c); | |
272 | /** ctor for tuple */ | |
273 | CharsDefn(Int p_c, Int p_r); | |
274 | /** ctor for block */ | |
275 | CharsDefn(Block *p_block); | |
276 | virtual ~CharsDefn(); | |
277 | virtual CharsDefn* clone() const; | |
278 | virtual void set_fullname(const string& p_fullname); | |
279 | virtual void set_my_scope(Scope *p_scope); | |
280 | selector_t get_selector() {return selector;} | |
281 | void chk(); | |
282 | string get_string(ReferenceChain *refch=0); | |
283 | ustring get_ustring(ReferenceChain *refch=0); | |
284 | string get_iso2022string(ReferenceChain *refch=0); | |
285 | size_t get_len(ReferenceChain *refch); | |
286 | virtual void dump(unsigned level) const; | |
287 | private: | |
288 | void parse_block(); | |
289 | }; | |
290 | ||
291 | /** | |
292 | * Universal charstring elements. | |
293 | */ | |
294 | class CharSyms : public Node, public Location { | |
295 | private: | |
296 | vector <CharsDefn> cds; | |
297 | enum selector_t { | |
298 | CS_UNDEF, | |
299 | CS_CHECKING, | |
300 | CS_CSTRING, | |
301 | CS_USTRING, | |
302 | CS_ISO2022STRING | |
303 | } selector; | |
304 | union { | |
305 | string *str; | |
306 | ustring *ustr; | |
307 | } u; | |
308 | CharSyms(const CharSyms& p); | |
309 | public: | |
310 | CharSyms(); | |
311 | virtual ~CharSyms(); | |
312 | virtual CharSyms* clone() const; | |
313 | virtual void set_fullname(const string& p_fullname); | |
314 | virtual void set_my_scope(Scope *p_scope); | |
315 | /** \a p_cd can be 0 in case of error => drop it */ | |
316 | void add_cd(CharsDefn *p_cd); | |
317 | void chk(bool tuple_enabled, bool quadruple_enabled); | |
318 | size_t get_nof_cds() const {return cds.size();} | |
319 | CharsDefn*& get_cd_byIndex(size_t p_i) {return cds[p_i];} | |
320 | string get_string(ReferenceChain *refch=0); | |
321 | ustring get_ustring(ReferenceChain *refch=0); | |
322 | string get_iso2022string(ReferenceChain *refch=0); | |
323 | size_t get_len(ReferenceChain *refch=0); | |
324 | virtual void dump(unsigned level) const; | |
325 | }; | |
326 | ||
327 | /** @} end of AST_Value group */ | |
328 | ||
329 | } // namespace Common | |
330 | ||
331 | #endif // _Common_Value_HH |