|
1 /* |
|
2 * (c) 2003 Mario de Sousa |
|
3 * |
|
4 * Offered to the public under the terms of the GNU General Public License |
|
5 * as published by the Free Software Foundation; either version 2 of the |
|
6 * License, or (at your option) any later version. |
|
7 * |
|
8 * This program is distributed in the hope that it will be useful, but |
|
9 * WITHOUT ANY WARRANTY; without even the implied warranty of |
|
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General |
|
11 * Public License for more details. |
|
12 * |
|
13 * This code is made available on the understanding that it will not be |
|
14 * used in safety-critical situations without a full and competent review. |
|
15 */ |
|
16 |
|
17 /* |
|
18 * An IEC 61131-3 IL and ST compiler. |
|
19 * |
|
20 * Based on the |
|
21 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10) |
|
22 * |
|
23 */ |
|
24 |
|
25 /* |
|
26 * Determine the default initial value of a type declaration. |
|
27 * |
|
28 * This is part of the 4th stage that generates |
|
29 * a c++ source program equivalent to the IL and ST |
|
30 * code. |
|
31 */ |
|
32 /* Given a type definition declration, determine its default |
|
33 * initial value. Note that types based on other types |
|
34 * may have to iterate through each type it is based on |
|
35 * to determine the initial value. |
|
36 * E.g. |
|
37 * TYPE |
|
38 * A_t : INT := 10; |
|
39 * B_t : A_t := 20; |
|
40 * C_t : B_t; |
|
41 * D_t : C_t := 40; |
|
42 * END_TYPE |
|
43 * Where the default initial value for C_t is 20! |
|
44 */ |
|
45 /* NOTE: The main program only needs one instance of |
|
46 * this class of object. This class |
|
47 * is therefore a singleton. |
|
48 */ |
|
49 |
|
50 |
|
51 #include "absyntax_utils.hh" |
|
52 |
|
53 //#define DEBUG |
|
54 #ifdef DEBUG |
|
55 #define TRACE(classname) printf("\n____%s____\n",classname); |
|
56 #else |
|
57 #define TRACE(classname) |
|
58 #endif |
|
59 |
|
60 |
|
61 type_initial_value_c *type_initial_value_c::instance(void) { |
|
62 if (_instance != NULL) |
|
63 return _instance; |
|
64 |
|
65 _instance = new type_initial_value_c; |
|
66 |
|
67 real_0 = new real_c("0"); |
|
68 integer_0 = new integer_c("0"); |
|
69 integer_1 = new integer_c("1"); |
|
70 bool_0 = new boolean_literal_c(new bool_type_name_c(),new boolean_false_c()); |
|
71 /* FIXME: Our current implementation only allows dates from 1970 onwards, |
|
72 * but the standard defines the date 0001-01-01 as the default value |
|
73 * for the DATE data type. Untill we fix our implementation, we use 1970-01-01 |
|
74 * as our default value!! |
|
75 */ |
|
76 date_literal_0 = new date_literal_c(integer_1, integer_1, integer_1); |
|
77 date_literal_0 = new date_literal_c(new integer_c("1970"), integer_1, integer_1); |
|
78 daytime_literal_0 = new daytime_c(integer_0, integer_0, real_0); |
|
79 time_0 = new duration_c(NULL, new seconds_c(integer_0, NULL)); // T#0S |
|
80 date_0 = new date_c(date_literal_0); // D#0001-01-01 |
|
81 tod_0 = new time_of_day_c(daytime_literal_0); // TOD#00:00:00 |
|
82 dt_0 = new date_and_time_c(date_literal_0, daytime_literal_0); // DT#0001-01-01-00:00:00 |
|
83 string_0 = new single_byte_character_string_c("''"); |
|
84 wstring_0 = new double_byte_character_string_c("\"\""); |
|
85 |
|
86 return _instance; |
|
87 } |
|
88 |
|
89 type_initial_value_c::type_initial_value_c(void) {} |
|
90 |
|
91 |
|
92 |
|
93 symbol_c *type_initial_value_c::get(identifier_c *type_name) { |
|
94 TRACE("type_initial_value_c::get(): called "); |
|
95 return (symbol_c *)type_name->accept(*this); |
|
96 } |
|
97 |
|
98 |
|
99 |
|
100 |
|
101 void *type_initial_value_c::handle_type_spec(symbol_c *base_type_name, symbol_c *type_spec_init) { |
|
102 if (type_spec_init != NULL) |
|
103 return type_spec_init; |
|
104 /* no initial value specified, so we return |
|
105 * the initial value of the type this type is based on... |
|
106 */ |
|
107 return base_type_name->accept(*this); |
|
108 } |
|
109 |
|
110 |
|
111 |
|
112 void *type_initial_value_c::visit(identifier_c *type_name) { |
|
113 /* look up the type declaration... */ |
|
114 symbol_c *type_decl = type_symtable.find_value(type_name); |
|
115 if (type_decl == type_symtable.end_value()) |
|
116 /* Type declaration not found!! */ |
|
117 /* NOTE: Variables declared out of function block 'data types', |
|
118 * for eg: VAR timer: TON; END_VAR |
|
119 * do not have a default value, so (TON) will never be found in the |
|
120 * type symbol table. This means we cannot simply consider this |
|
121 * an error and abort, but must rather return a NULL. |
|
122 */ |
|
123 return NULL; |
|
124 |
|
125 return type_decl->accept(*this); |
|
126 } |
|
127 |
|
128 /***********************************/ |
|
129 /* B 1.3.1 - Elementary Data Types */ |
|
130 /***********************************/ |
|
131 void *type_initial_value_c::visit(time_type_name_c *symbol) {return (void *)time_0;} |
|
132 void *type_initial_value_c::visit(bool_type_name_c *symbol) {return (void *)bool_0;} |
|
133 void *type_initial_value_c::visit(sint_type_name_c *symbol) {return (void *)integer_0;} |
|
134 void *type_initial_value_c::visit(int_type_name_c *symbol) {return (void *)integer_0;} |
|
135 void *type_initial_value_c::visit(dint_type_name_c *symbol) {return (void *)integer_0;} |
|
136 void *type_initial_value_c::visit(lint_type_name_c *symbol) {return (void *)integer_0;} |
|
137 void *type_initial_value_c::visit(usint_type_name_c *symbol) {return (void *)integer_0;} |
|
138 void *type_initial_value_c::visit(uint_type_name_c *symbol) {return (void *)integer_0;} |
|
139 void *type_initial_value_c::visit(udint_type_name_c *symbol) {return (void *)integer_0;} |
|
140 void *type_initial_value_c::visit(ulint_type_name_c *symbol) {return (void *)integer_0;} |
|
141 void *type_initial_value_c::visit(real_type_name_c *symbol) {return (void *)real_0;} |
|
142 void *type_initial_value_c::visit(lreal_type_name_c *symbol) {return (void *)real_0;} |
|
143 void *type_initial_value_c::visit(date_type_name_c *symbol) {return (void *)date_0;} |
|
144 void *type_initial_value_c::visit(tod_type_name_c *symbol) {return (void *)tod_0;} |
|
145 void *type_initial_value_c::visit(dt_type_name_c *symbol) {return (void *)dt_0;} |
|
146 void *type_initial_value_c::visit(byte_type_name_c *symbol) {return (void *)integer_0;} |
|
147 void *type_initial_value_c::visit(word_type_name_c *symbol) {return (void *)integer_0;} |
|
148 void *type_initial_value_c::visit(dword_type_name_c *symbol) {return (void *)integer_0;} |
|
149 void *type_initial_value_c::visit(lword_type_name_c *symbol) {return (void *)integer_0;} |
|
150 void *type_initial_value_c::visit(string_type_name_c *symbol) {return (void *)string_0;} |
|
151 void *type_initial_value_c::visit(wstring_type_name_c *symbol) {return (void *)wstring_0;} |
|
152 |
|
153 /********************************/ |
|
154 /* B 1.3.3 - Derived data types */ |
|
155 /********************************/ |
|
156 /* simple_type_name ':' simple_spec_init */ |
|
157 void *type_initial_value_c::visit(simple_type_declaration_c *symbol) { |
|
158 return symbol->simple_spec_init->accept(*this); |
|
159 } |
|
160 /* simple_specification ASSIGN constant */ |
|
161 void *type_initial_value_c::visit(simple_spec_init_c *symbol) { |
|
162 return handle_type_spec(symbol->simple_specification, symbol->constant); |
|
163 } |
|
164 /* subrange_type_name ':' subrange_spec_init */ |
|
165 void *type_initial_value_c::visit(subrange_type_declaration_c *symbol) { |
|
166 return symbol->subrange_spec_init->accept(*this); |
|
167 } |
|
168 /* subrange_specification ASSIGN signed_integer */ |
|
169 void *type_initial_value_c::visit(subrange_spec_init_c *symbol) { |
|
170 return handle_type_spec(symbol->subrange_specification, symbol->signed_integer); |
|
171 } |
|
172 /* integer_type_name '(' subrange')' */ |
|
173 void *type_initial_value_c::visit(subrange_specification_c *symbol) { |
|
174 /* if no initial value explicitly given, then use the lowest value of the subrange */ |
|
175 if (symbol->subrange != NULL) |
|
176 return symbol->subrange->accept(*this); |
|
177 else |
|
178 return symbol->integer_type_name->accept(*this); |
|
179 } |
|
180 /* signed_integer DOTDOT signed_integer */ |
|
181 void *type_initial_value_c::visit(subrange_c *symbol) {return symbol->lower_limit;} |
|
182 /* enumerated_type_name ':' enumerated_spec_init */ |
|
183 void *type_initial_value_c::visit(enumerated_type_declaration_c *symbol) { |
|
184 return symbol->enumerated_spec_init->accept(*this); |
|
185 } |
|
186 /* enumerated_specification ASSIGN enumerated_value */ |
|
187 void *type_initial_value_c::visit(enumerated_spec_init_c *symbol) { |
|
188 return handle_type_spec(symbol->enumerated_specification, symbol->enumerated_value); |
|
189 } |
|
190 /* helper symbol for enumerated_specification->enumerated_spec_init */ |
|
191 /* enumerated_value_list ',' enumerated_value */ |
|
192 void *type_initial_value_c::visit(enumerated_value_list_c *symbol) { |
|
193 /* if no initial value explicitly given, then use the lowest value of the subrange */ |
|
194 return (void *)symbol->elements[0]; |
|
195 } |
|
196 /* enumerated_type_name '#' identifier */ |
|
197 // SYM_REF2(enumerated_value_c, type, value) |
|
198 void *type_initial_value_c::visit(enumerated_value_c *symbol) {ERROR; return NULL;} |
|
199 /* identifier ':' array_spec_init */ |
|
200 void *type_initial_value_c::visit(array_type_declaration_c *symbol) { |
|
201 return symbol->array_spec_init->accept(*this); |
|
202 } |
|
203 /* array_specification [ASSIGN array_initialization} */ |
|
204 /* array_initialization may be NULL ! */ |
|
205 void *type_initial_value_c::visit(array_spec_init_c *symbol) { |
|
206 return handle_type_spec(symbol->array_specification, symbol->array_initialization); |
|
207 } |
|
208 /* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */ |
|
209 void *type_initial_value_c::visit(array_specification_c *symbol) { |
|
210 //symbol_c *init_value = (symbol_c *)symbol->non_generic_type_name->accept(*this); |
|
211 |
|
212 /* Now build a array_initial_elements_list_c list, and populate it |
|
213 * with 1 element of the array_initial_elements_c class |
|
214 */ |
|
215 /* The array_initial_elements_c will contain a reference to the init_value, |
|
216 * and another constant representing the number of elements in the array. |
|
217 * In essence, we are building the equivilant of the following ST/IL code: |
|
218 * New_array_t : ARRAY [1..30, 51..60] of INT := [40(XXX)]; |
|
219 * from the user given code |
|
220 * New_array_t : ARRAY [1..30, 51..60] of INT; |
|
221 * and replacing XXX with the default initial value of INT. |
|
222 */ |
|
223 /* now we need to determine the number of elements in the array... */ |
|
224 /* Easier said than done, as the array may have a list of subranges, as in the |
|
225 * example given above!! |
|
226 */ |
|
227 /* TODO !!!!!*/ |
|
228 /* For now, just assume an array with 1 element. |
|
229 * I (Mario) want to finish off this part of the code before getting boged down |
|
230 * in something else... |
|
231 */ |
|
232 // NOTE: We are leaking memory, as the integer will never get free'd!! |
|
233 //integer_c *integer = new integer_c("1"); |
|
234 // NOTE: We are leaking memory, as the array_initial_elements will never get free'd!! |
|
235 //array_initial_elements_c *array_initial_elements = new array_initial_elements_c(integer, init_value); |
|
236 // NOTE: We are leaking memory, as the array_initial_elements_list will never get free'd!! |
|
237 array_initial_elements_list_c *array_initial_elements_list = new array_initial_elements_list_c(); |
|
238 //array_initial_elements_list->add_element(array_initial_elements); |
|
239 return array_initial_elements_list; |
|
240 } |
|
241 /* helper symbol for array_specification */ |
|
242 /* array_subrange_list ',' subrange */ |
|
243 void *type_initial_value_c::visit(array_subrange_list_c *symbol) {ERROR; return NULL;} |
|
244 /* array_initialization: '[' array_initial_elements_list ']' */ |
|
245 /* helper symbol for array_initialization */ |
|
246 /* array_initial_elements_list ',' array_initial_elements */ |
|
247 void *type_initial_value_c::visit(array_initial_elements_list_c *symbol) {ERROR; return NULL;} |
|
248 /* integer '(' [array_initial_element] ')' */ |
|
249 /* array_initial_element may be NULL ! */ |
|
250 void *type_initial_value_c::visit(array_initial_elements_c *symbol) {ERROR; return NULL;} |
|
251 |
|
252 |
|
253 |
|
254 /* TODO: from this point forward... */ |
|
255 |
|
256 /* structure_type_name ':' structure_specification */ |
|
257 void *type_initial_value_c::visit(structure_type_declaration_c *symbol) {return NULL;} |
|
258 /* structure_type_name ASSIGN structure_initialization */ |
|
259 /* structure_initialization may be NULL ! */ |
|
260 void *type_initial_value_c::visit(initialized_structure_c *symbol) { |
|
261 return handle_type_spec(symbol->structure_type_name, symbol->structure_initialization); |
|
262 } |
|
263 /* helper symbol for structure_declaration */ |
|
264 /* structure_declaration: STRUCT structure_element_declaration_list END_STRUCT */ |
|
265 /* structure_element_declaration_list structure_element_declaration ';' */ |
|
266 void *type_initial_value_c::visit(structure_element_declaration_list_c *symbol) { |
|
267 structure_element_initialization_list_c *structure_element_initialization_list = new structure_element_initialization_list_c(); |
|
268 return structure_element_initialization_list; |
|
269 } |
|
270 /* structure_element_name ':' *_spec_init */ |
|
271 void *type_initial_value_c::visit(structure_element_declaration_c *symbol) {return NULL;} |
|
272 /* helper symbol for structure_initialization */ |
|
273 /* structure_initialization: '(' structure_element_initialization_list ')' */ |
|
274 /* structure_element_initialization_list ',' structure_element_initialization */ |
|
275 void *type_initial_value_c::visit(structure_element_initialization_list_c *symbol) {return NULL;} |
|
276 /* structure_element_name ASSIGN value */ |
|
277 void *type_initial_value_c::visit(structure_element_initialization_c *symbol) {return NULL;} |
|
278 /* string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */ |
|
279 /* |
|
280 * NOTE: |
|
281 * (Summary: Contrary to what is expected, the |
|
282 * string_type_declaration_c is not used to store |
|
283 * simple string type declarations that do not include |
|
284 * size limits. |
|
285 * For e.g.: |
|
286 * str1_type: STRING := "hello!" |
|
287 * will be stored in a simple_type_declaration_c |
|
288 * instead of a string_type_declaration_c. |
|
289 * The following: |
|
290 * str2_type: STRING [64] := "hello!" |
|
291 * will be stored in a sring_type_declaration_c |
|
292 * |
|
293 * Read on for why this is done... |
|
294 * End Summary) |
|
295 * |
|
296 * According to the spec, the valid construct |
|
297 * TYPE new_str_type : STRING := "hello!"; END_TYPE |
|
298 * has two possible routes to type_declaration... |
|
299 * |
|
300 * Route 1: |
|
301 * type_declaration: single_element_type_declaration |
|
302 * single_element_type_declaration: simple_type_declaration |
|
303 * simple_type_declaration: identifier ':' simple_spec_init |
|
304 * simple_spec_init: simple_specification ASSIGN constant |
|
305 * (shift: identifier <- 'new_str_type') |
|
306 * simple_specification: elementary_type_name |
|
307 * elementary_type_name: STRING |
|
308 * (shift: elementary_type_name <- STRING) |
|
309 * (reduce: simple_specification <- elementary_type_name) |
|
310 * (shift: constant <- "hello!") |
|
311 * (reduce: simple_spec_init: simple_specification ASSIGN constant) |
|
312 * (reduce: ...) |
|
313 * |
|
314 * |
|
315 * Route 2: |
|
316 * type_declaration: string_type_declaration |
|
317 * string_type_declaration: identifier ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init |
|
318 * (shift: identifier <- 'new_str_type') |
|
319 * elementary_string_type_name: STRING |
|
320 * (shift: elementary_string_type_name <- STRING) |
|
321 * (shift: string_type_declaration_size <- empty ) |
|
322 * string_type_declaration_init: ASSIGN character_string |
|
323 * (shift: character_string <- "hello!") |
|
324 * (reduce: string_type_declaration_init <- ASSIGN character_string) |
|
325 * (reduce: string_type_declaration <- identifier ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init ) |
|
326 * (reduce: type_declaration <- string_type_declaration) |
|
327 * |
|
328 * |
|
329 * At first glance it seems that removing route 1 would make |
|
330 * the most sense. Unfortunately the construct 'simple_spec_init' |
|
331 * shows up multiple times in other rules, so changing this construct |
|
332 * would also mean changing all the rules in which it appears. |
|
333 * I (Mario) therefore chose to remove route 2 instead. This means |
|
334 * that the above declaration gets stored in a |
|
335 * simple_type_declaration_c, and not in a string_type_declaration_c |
|
336 * as would be expected! |
|
337 */ |
|
338 /* string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */ |
|
339 #if 0 |
|
340 SYM_REF4(string_type_declaration_c, string_type_name, |
|
341 elementary_string_type_name, |
|
342 string_type_declaration_size, |
|
343 string_type_declaration_init) /* may be == NULL! */ |
|
344 #endif |
|
345 void *type_initial_value_c::visit(string_type_declaration_c *symbol) {return NULL;} |
|
346 |
|
347 |
|
348 type_initial_value_c *type_initial_value_c::_instance = NULL; |
|
349 real_c *type_initial_value_c::real_0 = NULL; |
|
350 integer_c *type_initial_value_c::integer_0 = NULL; |
|
351 integer_c *type_initial_value_c::integer_1 = NULL; |
|
352 boolean_literal_c *type_initial_value_c::bool_0 = NULL; |
|
353 date_literal_c *type_initial_value_c::date_literal_0 = NULL; |
|
354 daytime_c *type_initial_value_c::daytime_literal_0 = NULL; |
|
355 duration_c *type_initial_value_c::time_0 = NULL; |
|
356 date_c *type_initial_value_c::date_0 = NULL; |
|
357 time_of_day_c *type_initial_value_c::tod_0 = NULL; |
|
358 date_and_time_c *type_initial_value_c::dt_0 = NULL; |
|
359 single_byte_character_string_c *type_initial_value_c::string_0 = NULL; |
|
360 double_byte_character_string_c *type_initial_value_c::wstring_0 = NULL; |