author | Paul Beltyukov <beltyukov.p.a@gmail.com> |
Tue, 09 May 2017 21:46:44 +0100 | |
changeset 1051 | e483512edbeb |
parent 1041 | 56ebe2a31b5b |
permissions | -rw-r--r-- |
70 | 1 |
/* |
279
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
267
diff
changeset
|
2 |
* matiec - a compiler for the programming languages defined in IEC 61131-3 |
70 | 3 |
* |
279
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
267
diff
changeset
|
4 |
* Copyright (C) 2003-2011 Mario de Sousa (msousa@fe.up.pt) |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
267
diff
changeset
|
5 |
* Copyright (C) 2007-2011 Laurent Bessard and Edouard Tisserant |
70 | 6 |
* |
279
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
267
diff
changeset
|
7 |
* This program is free software: you can redistribute it and/or modify |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
267
diff
changeset
|
8 |
* it under the terms of the GNU General Public License as published by |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
267
diff
changeset
|
9 |
* the Free Software Foundation, either version 3 of the License, or |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
267
diff
changeset
|
10 |
* (at your option) any later version. |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
267
diff
changeset
|
11 |
* |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
267
diff
changeset
|
12 |
* This program is distributed in the hope that it will be useful, |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
267
diff
changeset
|
13 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
267
diff
changeset
|
14 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
267
diff
changeset
|
15 |
* GNU General Public License for more details. |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
267
diff
changeset
|
16 |
* |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
267
diff
changeset
|
17 |
* You should have received a copy of the GNU General Public License |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
267
diff
changeset
|
18 |
* along with this program. If not, see <http://www.gnu.org/licenses/>. |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
267
diff
changeset
|
19 |
* |
70 | 20 |
* |
21 |
* This code is made available on the understanding that it will not be |
|
22 |
* used in safety-critical situations without a full and competent review. |
|
23 |
*/ |
|
24 |
||
139
668a54686827
added missing includes on some platform (gentoo/gcc-4.3.1)
etisserant
parents:
118
diff
changeset
|
25 |
#include <string.h> |
70 | 26 |
|
27 |
||
28 |
||
945
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
29 |
/* This file cotains two main classes: |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
30 |
* - generate_c_base_c |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
31 |
* - generate_c_base_and_typeid_c |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
32 |
* |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
33 |
* generate_c_base_c |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
34 |
* ----------------- |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
35 |
* This class generates C code for all literals and varables. In short, all the basic stuff |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
36 |
* that will probably be needed in all other code generating classes. |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
37 |
* It does not however handle derived datatypes. |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
38 |
* |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
39 |
* generate_c_base_and_typeid_c |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
40 |
* ---------------------------- |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
41 |
* This is similar to the generate_c_base_c (from which it inherits), but it also handles |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
42 |
* all the derived datatypes. Note that it does not generate C code for the declaration of |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
43 |
* those datatypes (that is what generate_c_typedecl_c is for), but rather it merely |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
44 |
* generates the name/id of a derived datatype. |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
45 |
* Note too that not all derived datatypes in the IEC 61131-3 have a name (for example, |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
46 |
* VAR a: ARRAY [3..5] of INT END_VAR), in which case an alias for this datatype should |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
47 |
* have been previously generated by either generate_c_typedecl_c or generate_implicit_typedecl_c. |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
48 |
*/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
49 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
50 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
51 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
52 |
|
70 | 53 |
|
149 | 54 |
typedef struct |
55 |
{ |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
56 |
symbol_c *param_name; |
149 | 57 |
symbol_c *param_value; |
58 |
symbol_c *param_type; |
|
59 |
function_param_iterator_c::param_direction_t param_direction; |
|
60 |
} FUNCTION_PARAM; |
|
61 |
||
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
62 |
#define DECLARE_PARAM_LIST()\ |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
63 |
std::list<FUNCTION_PARAM*> param_list;\ |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
64 |
std::list<FUNCTION_PARAM*>::iterator pt;\ |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
65 |
FUNCTION_PARAM *param; |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
66 |
|
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
67 |
#define ADD_PARAM_LIST(name, value, type, direction)\ |
149 | 68 |
param = new FUNCTION_PARAM;\ |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
69 |
param->param_name = name;\ |
149 | 70 |
param->param_value = value;\ |
71 |
param->param_type = type;\ |
|
72 |
param->param_direction = direction;\ |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
73 |
param_list.push_back(param); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
74 |
|
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
75 |
#define PARAM_LIST_ITERATOR() for(pt = param_list.begin(); pt != param_list.end(); pt++) |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
76 |
|
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
77 |
#define PARAM_NAME (*pt)->param_name |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
78 |
#define PARAM_VALUE (*pt)->param_value |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
79 |
#define PARAM_TYPE (*pt)->param_type |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
80 |
#define PARAM_DIRECTION (*pt)->param_direction |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
81 |
|
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
82 |
#define CLEAR_PARAM_LIST()\ |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
83 |
PARAM_LIST_ITERATOR()\ |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
84 |
delete *pt;\ |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
85 |
param_list.clear(); |
70 | 86 |
|
87 |
||
945
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
88 |
/* generate_c_base_c |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
89 |
* ----------------- |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
90 |
* This class generates C code for all literals and varables. In short, all the basic stuff |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
91 |
* that will probably be needed in all other code generating classes. |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
92 |
* It does not however handle derived datatypes. |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
93 |
*/ |
70 | 94 |
class generate_c_base_c: public iterator_visitor_c { |
95 |
||
96 |
protected: |
|
97 |
stage4out_c &s4o; |
|
98 |
||
99 |
private: |
|
100 |
/* Unlike programs that are mapped onto C++ classes, Function Blocks are mapped onto a data structure type |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
101 |
* and a separate function containing the code. This function is passed a pointer to an instance of the data |
70 | 102 |
* structure. This means that the code inside the functions must insert a pointer to the data structure whenever |
103 |
* it wishes to access a Function Block variable. |
|
104 |
* The variable_prefix_ variable will contain the correct string which needs to be prefixed to all variable accesses. |
|
105 |
* This string is set with the set_variable_prefix() member function. |
|
106 |
*/ |
|
107 |
const char *variable_prefix_; |
|
108 |
||
109 |
public: |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
110 |
generate_c_base_c(stage4out_c *s4o_ptr): s4o(*s4o_ptr) { |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
111 |
variable_prefix_ = NULL; |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
112 |
} |
70 | 113 |
~generate_c_base_c(void) {} |
114 |
||
115 |
void set_variable_prefix(const char *variable_prefix) {variable_prefix_ = variable_prefix;} |
|
160 | 116 |
const char *get_variable_prefix(void) {return variable_prefix_;} |
146
eef5e62048c7
Adding support for EN/ENO params in function and function blocks (standard function not supported yet)
lbessard
parents:
139
diff
changeset
|
117 |
bool is_variable_prefix_null(void) {return variable_prefix_ == NULL;} |
70 | 118 |
void print_variable_prefix(void) { |
119 |
if (variable_prefix_ != NULL) |
|
120 |
s4o.print(variable_prefix_); |
|
121 |
} |
|
122 |
||
877 | 123 |
void print_line_directive(symbol_c *symbol) { |
878 | 124 |
if (!generate_line_directives__) return; /* global variable generate_line_directives__ is defined in generate_c.cc */ |
877 | 125 |
s4o.print("#line "); |
126 |
s4o.print(symbol->first_line); |
|
127 |
s4o.print(" \""); |
|
128 |
s4o.print(symbol->first_file); |
|
129 |
s4o.print("\"\n"); |
|
130 |
} |
|
131 |
||
70 | 132 |
void *print_token(token_c *token, int offset = 0) { |
133 |
return s4o.printupper((token->value)+offset); |
|
134 |
} |
|
135 |
||
136 |
void *print_literal(symbol_c *type, symbol_c *value) { |
|
137 |
s4o.print("__"); |
|
138 |
type->accept(*this); |
|
139 |
s4o.print("_LITERAL("); |
|
140 |
value->accept(*this); |
|
141 |
s4o.print(")"); |
|
142 |
return NULL; |
|
143 |
} |
|
144 |
||
145 |
void *print_striped_token(token_c *token, int offset = 0) { |
|
146 |
std::string str = ""; |
|
312
29add821207d
Fix bug when generating integer with leading zero (octal value for C compiler)
laurent
parents:
308
diff
changeset
|
147 |
bool leading_zero = true; |
29add821207d
Fix bug when generating integer with leading zero (octal value for C compiler)
laurent
parents:
308
diff
changeset
|
148 |
for (unsigned int i = offset; i < strlen(token->value); i++) { |
927 | 149 |
if (leading_zero |
150 |
&& ( token->value[i] != '0' |
|
151 |
|| i == strlen(token->value) - 1 |
|
152 |
|| token->value[i + 1] == '.' |
|
153 |
) |
|
154 |
) |
|
312
29add821207d
Fix bug when generating integer with leading zero (octal value for C compiler)
laurent
parents:
308
diff
changeset
|
155 |
leading_zero = false; |
927 | 156 |
if (!leading_zero && token->value[i] != '_') |
70 | 157 |
str += token->value[i]; |
312
29add821207d
Fix bug when generating integer with leading zero (octal value for C compiler)
laurent
parents:
308
diff
changeset
|
158 |
} |
70 | 159 |
return s4o.printupper(str); |
160 |
} |
|
161 |
||
162 |
void *print_striped_binary_token(token_c *token, unsigned int offset = 0) { |
|
163 |
/* convert the binary value to hexadecimal format... */ |
|
164 |
unsigned char value, bit_mult; |
|
165 |
unsigned int i; |
|
166 |
int total_bits; |
|
167 |
char str[2] = {'A', '\0'}; /* since the s4o object is not prepared to print out one character at a time... */ |
|
168 |
||
169 |
s4o.print("0x"); |
|
170 |
||
171 |
total_bits = 0; |
|
172 |
for (i = offset; i < strlen(token->value); i++) |
|
173 |
if (token->value[i] != '_') |
|
927 | 174 |
total_bits++; |
70 | 175 |
|
176 |
value = 0; |
|
177 |
bit_mult = (unsigned char)1 << (((total_bits+3)%4)+1); |
|
178 |
for (i = offset; i < strlen(token->value); i++) { |
|
179 |
if (token->value[i] != '_') { |
|
927 | 180 |
bit_mult /= 2; |
181 |
value += bit_mult * ((token->value[i] == '0')? 0:1); |
|
182 |
if (bit_mult == 1) { |
|
183 |
str[0] = (value <= 9)? (char)'0' + value : (char)'A' + value - 10; |
|
184 |
s4o.print(str); |
|
70 | 185 |
bit_mult = 0x10; |
186 |
value = 0; |
|
927 | 187 |
} |
188 |
} |
|
70 | 189 |
} |
190 |
||
191 |
return NULL; |
|
192 |
} |
|
193 |
||
194 |
void *print_list(list_c *list, |
|
927 | 195 |
std::string pre_elem_str = "", |
196 |
std::string inter_elem_str = "", |
|
197 |
std::string post_elem_str = "", |
|
198 |
visitor_c *visitor = NULL) { |
|
70 | 199 |
if (visitor == NULL) visitor = this; |
200 |
||
201 |
if (list->n > 0) { |
|
202 |
//std::cout << "generate_c_base_c::print_list(n = " << list->n << ") 000\n"; |
|
203 |
s4o.print(pre_elem_str); |
|
1041
56ebe2a31b5b
Access elements[] in list_c through a new get_element() method.
Mario de Sousa <msousa@fe.up.pt>
parents:
1016
diff
changeset
|
204 |
list->get_element(0)->accept(*visitor); |
70 | 205 |
} |
206 |
||
207 |
for(int i = 1; i < list->n; i++) { |
|
208 |
//std::cout << "generate_c_base_c::print_list " << i << "\n"; |
|
209 |
s4o.print(inter_elem_str); |
|
1041
56ebe2a31b5b
Access elements[] in list_c through a new get_element() method.
Mario de Sousa <msousa@fe.up.pt>
parents:
1016
diff
changeset
|
210 |
list->get_element(i)->accept(*visitor); |
70 | 211 |
} |
212 |
||
213 |
if (list->n > 0) |
|
214 |
s4o.print(post_elem_str); |
|
215 |
||
216 |
return NULL; |
|
217 |
} |
|
218 |
||
219 |
||
220 |
void *print_binary_expression(symbol_c *l_exp, |
|
927 | 221 |
symbol_c *r_exp, |
222 |
const char *operation) { |
|
70 | 223 |
s4o.print("("); |
224 |
l_exp->accept(*this); |
|
225 |
s4o.print(operation); |
|
226 |
r_exp->accept(*this); |
|
227 |
s4o.print(")"); |
|
228 |
return NULL; |
|
229 |
} |
|
230 |
||
231 |
void *print_unary_expression(symbol_c *exp, |
|
927 | 232 |
const char *operation) { |
70 | 233 |
s4o.print(operation); |
234 |
s4o.print("("); |
|
235 |
exp->accept(*this); |
|
236 |
s4o.print(")"); |
|
237 |
return NULL; |
|
238 |
} |
|
239 |
||
240 |
void *print_binary_function(const char *function, |
|
241 |
symbol_c *l_exp, |
|
927 | 242 |
symbol_c *r_exp) { |
70 | 243 |
s4o.print(function); |
244 |
s4o.print("("); |
|
245 |
l_exp->accept(*this); |
|
246 |
s4o.print(", "); |
|
247 |
r_exp->accept(*this); |
|
248 |
s4o.print(")"); |
|
249 |
return NULL; |
|
927 | 250 |
} |
70 | 251 |
|
1011
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
252 |
/* Call a standard library function that does a comparison (GT, NE, EQ, LT, ...) |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
253 |
* NOTE: Typically, the function will have the following parameters: |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
254 |
* 1st parameter: EN (enable) |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
255 |
* 2nd parameter: ENO (enable output) |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
256 |
* 3rd parameter: number of operands we will be passing (required because we are calling an extensible standard function!) |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
257 |
* 4th parameter: the left hand side of the comparison expression (in out case, the IL implicit variable) |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
258 |
* 4th parameter: the right hand side of the comparison expression (in out case, current operand) |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
259 |
* |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
260 |
* The 1st and 2nd parameter may not be present, only issue them if NE and ENO are being generated! |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
261 |
* The 3rd parameter must not be generated when the 'NE' function is called (it is not an extensible function!) |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
262 |
* |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
263 |
* NOTE: To implement this correctly, this function should really instantiate a |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
264 |
* function_invocation_c and have the generate_c visitor generate the code automatically for this |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
265 |
* function invocation. However, the code for function invocations is currently duplicated |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
266 |
* for IL and ST. Until this code is not re-formulated into a single piece of general code, for now |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
267 |
* we generate the function call directly here in print_compare_function() |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
268 |
*/ |
70 | 269 |
void *print_compare_function(const char *function, |
270 |
symbol_c *compare_type, |
|
271 |
symbol_c *l_exp, |
|
272 |
symbol_c *r_exp) { |
|
1011
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
273 |
// Print out the name of the function we will call. |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
274 |
// It will be something like LE_TIME, LE_DATE, GT_DATE, ... |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
275 |
// (in other words, we are calling an overloaded function!) |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
276 |
s4o.print(function); // the GT, LE, ... part |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
277 |
s4o.print("_"); // the '_' part... |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
278 |
compare_type->accept(*this); // the TIME, DATE, ... part. |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
279 |
s4o.print("("); // start of parameters to function call... |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
280 |
// Determine whether this function has the EN parameter |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
281 |
// (we just check the base LE, GT, .. function, as it should have |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
282 |
// the same parameters as the overloaded function!) |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
283 |
function_symtable_t::iterator lower = function_symtable.lower_bound(function); |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
284 |
if (lower == function_symtable.end()) ERROR; // We want to call a function that does not exist!!?? Hmm... |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
285 |
search_var_instance_decl_c search_var(function_symtable.get_value(lower)); |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
286 |
identifier_c en_var("EN"); |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
287 |
identifier_c eno_var("ENO"); |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
288 |
if (search_var.get_vartype(& en_var) == search_var_instance_decl_c::input_vt) |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
289 |
s4o.print("__BOOL_LITERAL(TRUE), "); // function has EN parameter, pass TRUE |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
290 |
if (search_var.get_vartype(&eno_var) == search_var_instance_decl_c::output_vt) |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
291 |
s4o.print("NULL, "); // function has ENO parameter, pass NULL |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
292 |
if (strcmp(function, "NE") != 0) // All comparison library functions are extensible, except for 'NE'!! |
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
966
diff
changeset
|
293 |
s4o.print("2, "); // function is extensible, so must first pass the number of parameters that follow |
70 | 294 |
l_exp->accept(*this); |
295 |
s4o.print(", "); |
|
296 |
r_exp->accept(*this); |
|
297 |
s4o.print(")"); |
|
298 |
return NULL; |
|
299 |
} |
|
300 |
||
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
301 |
void *print_check_function(symbol_c *type, |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
302 |
symbol_c *value, |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
303 |
symbol_c *fb_name = NULL, |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
304 |
bool temp = false) { |
854
13d0b67de111
Code cleanup: move datatype analysis to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
793
diff
changeset
|
305 |
if (!get_datatype_info_c::is_type_valid(type)) ERROR; |
13d0b67de111
Code cleanup: move datatype analysis to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
793
diff
changeset
|
306 |
bool is_subrange = get_datatype_info_c::is_subrange(type); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
307 |
if (is_subrange) { |
927 | 308 |
s4o.print("__CHECK_"); |
309 |
type->accept(*this); |
|
310 |
s4o.print("("); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
311 |
} |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
312 |
if (fb_name != NULL) { |
240 | 313 |
s4o.print(GET_VAR); |
314 |
s4o.print("("); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
315 |
print_variable_prefix(); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
316 |
fb_name->accept(*this); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
317 |
s4o.print("."); |
240 | 318 |
value->accept(*this); |
319 |
s4o.print(")"); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
320 |
} |
240 | 321 |
else { |
322 |
if (temp) |
|
927 | 323 |
s4o.print(TEMP_VAR); |
240 | 324 |
value->accept(*this); |
325 |
} |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
326 |
if (is_subrange) |
240 | 327 |
s4o.print(")"); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
328 |
return NULL; |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
329 |
} |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
330 |
|
267
0a1204bcc9af
starting to add proper header file with declaration of standard functions
Mario de Sousa <msousa@fe.up.pt>
parents:
258
diff
changeset
|
331 |
/********************/ |
0a1204bcc9af
starting to add proper header file with declaration of standard functions
Mario de Sousa <msousa@fe.up.pt>
parents:
258
diff
changeset
|
332 |
/* 2.1.6 - Pragmas */ |
0a1204bcc9af
starting to add proper header file with declaration of standard functions
Mario de Sousa <msousa@fe.up.pt>
parents:
258
diff
changeset
|
333 |
/********************/ |
0a1204bcc9af
starting to add proper header file with declaration of standard functions
Mario de Sousa <msousa@fe.up.pt>
parents:
258
diff
changeset
|
334 |
void *visit(enable_code_generation_pragma_c * symbol) {s4o.enable_output(); return NULL;} |
0a1204bcc9af
starting to add proper header file with declaration of standard functions
Mario de Sousa <msousa@fe.up.pt>
parents:
258
diff
changeset
|
335 |
void *visit(disable_code_generation_pragma_c * symbol) {s4o.disable_output(); return NULL;} |
0a1204bcc9af
starting to add proper header file with declaration of standard functions
Mario de Sousa <msousa@fe.up.pt>
parents:
258
diff
changeset
|
336 |
|
70 | 337 |
/* Do not use print_token() as it will change everything into uppercase */ |
634
736b36a83548
Added double curly braces for pragma (kept single curly braces for compatibility). Added macro def and undef surrounding pragma to simplify user code. Moved useless comment from generated code back to code generator.
Edouard Tisserant
parents:
594
diff
changeset
|
338 |
void *visit(pragma_c *symbol) { |
736b36a83548
Added double curly braces for pragma (kept single curly braces for compatibility). Added macro def and undef surrounding pragma to simplify user code. Moved useless comment from generated code back to code generator.
Edouard Tisserant
parents:
594
diff
changeset
|
339 |
s4o.print("#define GetFbVar(var,...) __GET_VAR(data__->var,__VA_ARGS__)\n"); |
736b36a83548
Added double curly braces for pragma (kept single curly braces for compatibility). Added macro def and undef surrounding pragma to simplify user code. Moved useless comment from generated code back to code generator.
Edouard Tisserant
parents:
594
diff
changeset
|
340 |
s4o.print(s4o.indent_spaces); |
886
111414d79ecd
Finish: Change order of SET_xxx() macros. (this will allow me to simplify the print_setter() methods later on)
mjsousa
parents:
878
diff
changeset
|
341 |
s4o.print("#define SetFbVar(var,val,...) __SET_VAR(data__->,var,__VA_ARGS__,val)\n"); |
634
736b36a83548
Added double curly braces for pragma (kept single curly braces for compatibility). Added macro def and undef surrounding pragma to simplify user code. Moved useless comment from generated code back to code generator.
Edouard Tisserant
parents:
594
diff
changeset
|
342 |
s4o.print(symbol->value); |
736b36a83548
Added double curly braces for pragma (kept single curly braces for compatibility). Added macro def and undef surrounding pragma to simplify user code. Moved useless comment from generated code back to code generator.
Edouard Tisserant
parents:
594
diff
changeset
|
343 |
s4o.print("\n"); |
736b36a83548
Added double curly braces for pragma (kept single curly braces for compatibility). Added macro def and undef surrounding pragma to simplify user code. Moved useless comment from generated code back to code generator.
Edouard Tisserant
parents:
594
diff
changeset
|
344 |
s4o.print(s4o.indent_spaces); |
736b36a83548
Added double curly braces for pragma (kept single curly braces for compatibility). Added macro def and undef surrounding pragma to simplify user code. Moved useless comment from generated code back to code generator.
Edouard Tisserant
parents:
594
diff
changeset
|
345 |
s4o.print("#undef GetFbVar\n"); |
736b36a83548
Added double curly braces for pragma (kept single curly braces for compatibility). Added macro def and undef surrounding pragma to simplify user code. Moved useless comment from generated code back to code generator.
Edouard Tisserant
parents:
594
diff
changeset
|
346 |
s4o.print(s4o.indent_spaces); |
736b36a83548
Added double curly braces for pragma (kept single curly braces for compatibility). Added macro def and undef surrounding pragma to simplify user code. Moved useless comment from generated code back to code generator.
Edouard Tisserant
parents:
594
diff
changeset
|
347 |
s4o.print("#undef SetFbVar\n"); |
736b36a83548
Added double curly braces for pragma (kept single curly braces for compatibility). Added macro def and undef surrounding pragma to simplify user code. Moved useless comment from generated code back to code generator.
Edouard Tisserant
parents:
594
diff
changeset
|
348 |
return NULL; |
736b36a83548
Added double curly braces for pragma (kept single curly braces for compatibility). Added macro def and undef surrounding pragma to simplify user code. Moved useless comment from generated code back to code generator.
Edouard Tisserant
parents:
594
diff
changeset
|
349 |
} |
70 | 350 |
|
351 |
||
352 |
/***************************/ |
|
353 |
/* B 0 - Programming Model */ |
|
354 |
/***************************/ |
|
355 |
/* leave for derived classes... */ |
|
356 |
||
357 |
||
358 |
||
359 |
/*************************/ |
|
360 |
/* B.1 - Common elements */ |
|
361 |
/*************************/ |
|
362 |
/*******************************************/ |
|
363 |
/* B 1.1 - Letters, digits and identifiers */ |
|
364 |
/*******************************************/ |
|
958
7474d2cd1d6e
Add a new pou_typename_c object to the AST to store references to previously declared Functions, FB, and Programs.
mjsousa
parents:
947
diff
changeset
|
365 |
void *visit( identifier_c *symbol) {return print_token(symbol);} |
7474d2cd1d6e
Add a new pou_typename_c object to the AST to store references to previously declared Functions, FB, and Programs.
mjsousa
parents:
947
diff
changeset
|
366 |
void *visit( poutype_identifier_c *symbol) {return print_token(symbol);} |
945
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
367 |
/* If you need the derived_datatype_identifier_c visitor, then you should probably be |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
368 |
* inheriting from generate_c_base_and_typeid_c and not generate_c_base_c !! |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
369 |
*/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
370 |
void *visit(derived_datatype_identifier_c *symbol) {ERROR; return NULL;} |
70 | 371 |
|
372 |
/*********************/ |
|
373 |
/* B 1.2 - Constants */ |
|
374 |
/*********************/ |
|
375 |
/* originally empty... */ |
|
376 |
||
919
8da635655f37
Add support for the 'NULL' keyword, defined in version 3 of IEC 61131-3.
mjsousa
parents:
886
diff
changeset
|
377 |
/*********************************/ |
8da635655f37
Add support for the 'NULL' keyword, defined in version 3 of IEC 61131-3.
mjsousa
parents:
886
diff
changeset
|
378 |
/* B 1.2.XX - Reference Literals */ |
8da635655f37
Add support for the 'NULL' keyword, defined in version 3 of IEC 61131-3.
mjsousa
parents:
886
diff
changeset
|
379 |
/*********************************/ |
8da635655f37
Add support for the 'NULL' keyword, defined in version 3 of IEC 61131-3.
mjsousa
parents:
886
diff
changeset
|
380 |
/* defined in IEC 61131-3 v3 - Basically the 'NULL' keyword! */ |
8da635655f37
Add support for the 'NULL' keyword, defined in version 3 of IEC 61131-3.
mjsousa
parents:
886
diff
changeset
|
381 |
void *visit(ref_value_null_literal_c *symbol) {s4o.print("NULL"); return NULL;} |
8da635655f37
Add support for the 'NULL' keyword, defined in version 3 of IEC 61131-3.
mjsousa
parents:
886
diff
changeset
|
382 |
|
70 | 383 |
/******************************/ |
384 |
/* B 1.2.1 - Numeric Literals */ |
|
385 |
/******************************/ |
|
386 |
void *visit(real_c *symbol) {return print_striped_token(symbol);} |
|
387 |
void *visit(integer_c *symbol) {return print_striped_token(symbol);} |
|
388 |
void *visit(binary_integer_c *symbol) {return print_striped_binary_token(symbol, 2);} |
|
389 |
void *visit(octal_integer_c *symbol) {s4o.print("0"); return print_striped_token(symbol, 2);} |
|
390 |
void *visit(hex_integer_c *symbol) {s4o.print("0x"); return print_striped_token(symbol, 3);} |
|
391 |
||
257 | 392 |
void *visit(neg_real_c *symbol) { |
393 |
s4o.print("-"); |
|
394 |
symbol->exp->accept(*this); |
|
395 |
return NULL; |
|
396 |
} |
|
397 |
||
398 |
void *visit(neg_integer_c *symbol) { |
|
399 |
s4o.print("-"); |
|
400 |
symbol->exp->accept(*this); |
|
401 |
return NULL; |
|
402 |
} |
|
403 |
||
70 | 404 |
void *visit(integer_literal_c *symbol) {return print_literal(symbol->type, symbol->value);} |
405 |
void *visit(real_literal_c *symbol) {return print_literal(symbol->type, symbol->value);} |
|
406 |
void *visit(bit_string_literal_c *symbol) {return print_literal(symbol->type, symbol->value);} |
|
257 | 407 |
void *visit(boolean_literal_c *symbol) { |
408 |
if (NULL != symbol->type) |
|
409 |
return print_literal(symbol->type, symbol->value); |
|
410 |
else { |
|
927 | 411 |
bool_type_name_c bool_type; |
412 |
return print_literal(&bool_type, symbol->value); |
|
257 | 413 |
} |
414 |
} |
|
70 | 415 |
|
416 |
/* helper class for boolean_literal_c */ |
|
417 |
void *visit(boolean_true_c *symbol) {s4o.print("TRUE"); return NULL;} |
|
418 |
void *visit(boolean_false_c *symbol) {s4o.print("FALSE"); return NULL;} |
|
419 |
||
98 | 420 |
void *visit(neg_expression_c *symbol) { |
421 |
s4o.print("-"); |
|
422 |
symbol->exp->accept(*this); |
|
423 |
return NULL; |
|
424 |
} |
|
425 |
||
70 | 426 |
/*******************************/ |
427 |
/* B.1.2.2 Character Strings */ |
|
428 |
/*******************************/ |
|
429 |
void *visit(double_byte_character_string_c *symbol) { |
|
430 |
// TO DO ... |
|
431 |
ERROR; |
|
432 |
return print_token(symbol); |
|
433 |
} |
|
434 |
||
435 |
void *visit(single_byte_character_string_c *symbol) { |
|
436 |
std::string str = ""; |
|
437 |
unsigned int count = 0; |
|
438 |
str += '"'; |
|
439 |
/* we ignore the first and last bytes, they will be the character ' */ |
|
440 |
for (unsigned int i = 1; i < strlen(symbol->value) - 1; i++) { |
|
441 |
char c = symbol->value[i]; |
|
442 |
if ((c == '\\') || (c == '"')) |
|
443 |
{str += '\\'; str += c; count ++; continue;} |
|
444 |
if (c != '$') |
|
445 |
{str += c; count++; continue;} |
|
446 |
/* this should be safe, since the code has passed the syntax parser!! */ |
|
447 |
c = symbol->value[++i]; |
|
448 |
switch (c) { |
|
449 |
case '$': |
|
450 |
case '\'': |
|
451 |
{str += c; count++; continue;} |
|
452 |
case 'L': |
|
453 |
case 'l': |
|
454 |
{str += "\x0A"; /* LF */; count++; continue;} |
|
455 |
case 'N': |
|
456 |
case 'n': |
|
457 |
{str += "\\x0A"; /* NL */; count++; continue;} |
|
458 |
case 'P': |
|
459 |
case 'p': |
|
460 |
{str += "\\f"; /* FF */; count++; continue;} |
|
461 |
case 'R': |
|
462 |
case 'r': |
|
463 |
{str += "\\r"; /* CR */; count++; continue;} |
|
464 |
case 'T': |
|
465 |
case 't': |
|
466 |
{str += "\\t"; /* tab */; count++; continue;} |
|
467 |
default: { |
|
468 |
if (isxdigit(c)) { |
|
469 |
/* this should be safe, since the code has passed the syntax parser!! */ |
|
927 | 470 |
char c2 = symbol->value[++i]; |
471 |
if (isxdigit(c2)) { |
|
472 |
str += '\\'; str += 'x'; str += c; str += c2; |
|
473 |
count++; continue; |
|
474 |
} |
|
475 |
} |
|
70 | 476 |
} |
477 |
/* otherwise we have an invalid string!! */ |
|
478 |
/* This should not have got through the syntax parser! */ |
|
479 |
ERROR; |
|
480 |
} /* switch() */ |
|
481 |
} /* for() */ |
|
482 |
||
483 |
str += '"'; |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
484 |
s4o.print("__STRING_LITERAL("); |
594
c8092e909886
Clean up code (remove parsing of integers in stage 4).
Mario de Sousa <msousa@fe.up.pt>
parents:
547
diff
changeset
|
485 |
s4o.print(count); |
70 | 486 |
s4o.print(","); |
487 |
s4o.print(str); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
202
diff
changeset
|
488 |
s4o.print(")"); |
70 | 489 |
return NULL; |
490 |
} |
|
491 |
||
492 |
||
493 |
/***************************/ |
|
494 |
/* B 1.2.3 - Time Literals */ |
|
495 |
/***************************/ |
|
496 |
||
497 |
/************************/ |
|
498 |
/* B 1.2.3.1 - Duration */ |
|
499 |
/************************/ |
|
500 |
/* The following output is actually the parameters to the constructor of the TIME class! */ |
|
501 |
||
502 |
/* SYM_REF0(neg_time_c) */ |
|
503 |
void *visit(neg_time_c *symbol) {s4o.print("-1"); /* negative time value */; return NULL;} |
|
504 |
||
505 |
||
506 |
/* SYM_REF2(duration_c, neg, interval) */ |
|
507 |
void *visit(duration_c *symbol) { |
|
508 |
TRACE("duration_c"); |
|
509 |
s4o.print("__time_to_timespec("); |
|
547
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
510 |
|
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
511 |
if (NULL == symbol->neg) s4o.print("1"); /* positive time value */ |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
512 |
else symbol->neg->accept(*this); /* this will print '-1' :-) */ |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
513 |
|
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
514 |
s4o.print(", "); |
70 | 515 |
symbol->interval->accept(*this); |
516 |
s4o.print(")"); |
|
517 |
return NULL; |
|
518 |
} |
|
519 |
||
520 |
||
521 |
/* SYM_TOKEN(fixed_point_c) */ |
|
312
29add821207d
Fix bug when generating integer with leading zero (octal value for C compiler)
laurent
parents:
308
diff
changeset
|
522 |
void *visit(fixed_point_c *symbol) {return print_striped_token(symbol);} |
70 | 523 |
|
547
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
524 |
/* SYM_REF5(interval_c, days, hours, minutes, seconds, milliseconds) */ |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
525 |
void *visit(interval_c *symbol) { |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
526 |
TRACE("interval_c"); |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
527 |
/* s4o.print("0, 0, 0, 0, 0"); // milliseconds, seconds, minutes, hours, days */ |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
528 |
if (NULL == symbol->milliseconds) s4o.print("0"); /* milliseconds */ |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
529 |
else symbol->milliseconds->accept(*this); |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
530 |
s4o.print(", "); |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
531 |
|
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
532 |
if (NULL == symbol->seconds) s4o.print("0"); /* seconds */ |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
533 |
else symbol->seconds->accept(*this); |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
534 |
s4o.print(", "); |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
535 |
|
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
536 |
if (NULL == symbol->minutes) s4o.print("0"); /* minutes */ |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
537 |
else symbol->minutes->accept(*this); |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
538 |
s4o.print(", "); |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
539 |
|
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
540 |
if (NULL == symbol->hours) s4o.print("0"); /* hours */ |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
541 |
else symbol->hours->accept(*this); |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
542 |
s4o.print(", "); |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
543 |
|
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
544 |
if (NULL == symbol->days) s4o.print("0"); /* days */ |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
545 |
else symbol->days->accept(*this); |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
546 |
|
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
547 |
return NULL; |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
548 |
} |
dab341e80664
Fix parsing os TIME literals & rename the extract_integer() function.
mjsousa <msousa@fe.up.pt>
parents:
312
diff
changeset
|
549 |
|
70 | 550 |
|
551 |
/************************************/ |
|
552 |
/* B 1.2.3.2 - Time of day and Date */ |
|
553 |
/************************************/ |
|
554 |
||
555 |
/* SYM_REF2(time_of_day_c, daytime, unused) */ |
|
556 |
void *visit(time_of_day_c *symbol) { |
|
557 |
TRACE("time_of_day_c"); |
|
558 |
s4o.print("__tod_to_timespec("); |
|
559 |
symbol->daytime->accept(*this); |
|
560 |
s4o.print(")"); |
|
561 |
return NULL; |
|
562 |
} |
|
563 |
||
564 |
||
565 |
/* SYM_REF4(daytime_c, day_hour, day_minute, day_second, unused) */ |
|
566 |
void *visit(daytime_c *symbol) { |
|
567 |
TRACE("daytime_c"); |
|
568 |
symbol->day_second->accept(*this); |
|
569 |
s4o.print(", "); |
|
570 |
symbol->day_minute->accept(*this); |
|
571 |
s4o.print(", "); |
|
572 |
symbol->day_hour->accept(*this); |
|
573 |
return NULL; |
|
574 |
} |
|
575 |
||
576 |
||
577 |
/* SYM_REF2(date_c, date_literal, unused) */ |
|
578 |
void *visit(date_c *symbol) { |
|
579 |
TRACE("date_c"); |
|
580 |
s4o.print("__date_to_timespec("); |
|
581 |
symbol->date_literal->accept(*this); |
|
582 |
s4o.print(")"); |
|
583 |
return NULL; |
|
584 |
} |
|
585 |
||
586 |
||
587 |
/* SYM_REF4(date_literal_c, year, month, day, unused) */ |
|
588 |
void *visit(date_literal_c *symbol) { |
|
589 |
TRACE("date_literal_c"); |
|
590 |
symbol->day->accept(*this); |
|
591 |
s4o.print(", "); |
|
592 |
symbol->month->accept(*this); |
|
593 |
s4o.print(", "); |
|
594 |
symbol->year->accept(*this); |
|
595 |
return NULL; |
|
596 |
} |
|
597 |
||
598 |
||
599 |
/* SYM_REF2(date_and_time_c, date_literal, daytime) */ |
|
600 |
void *visit(date_and_time_c *symbol) { |
|
601 |
TRACE("date_and_time_c"); |
|
602 |
s4o.print("__dt_to_timespec("); |
|
603 |
symbol->daytime->accept(*this); |
|
604 |
s4o.print(", "); |
|
605 |
symbol->date_literal->accept(*this); |
|
606 |
s4o.print(")"); |
|
607 |
return NULL; |
|
608 |
} |
|
609 |
||
610 |
||
611 |
/**********************/ |
|
612 |
/* B.1.3 - Data types */ |
|
613 |
/**********************/ |
|
614 |
/***********************************/ |
|
615 |
/* B 1.3.1 - Elementary Data Types */ |
|
616 |
/***********************************/ |
|
257 | 617 |
void *visit(time_type_name_c *symbol) {s4o.print("TIME"); return NULL;} |
618 |
void *visit(bool_type_name_c *symbol) {s4o.print("BOOL"); return NULL;} |
|
619 |
void *visit(sint_type_name_c *symbol) {s4o.print("SINT"); return NULL;} |
|
620 |
void *visit(int_type_name_c *symbol) {s4o.print("INT"); return NULL;} |
|
621 |
void *visit(dint_type_name_c *symbol) {s4o.print("DINT"); return NULL;} |
|
622 |
void *visit(lint_type_name_c *symbol) {s4o.print("LINT"); return NULL;} |
|
623 |
void *visit(usint_type_name_c *symbol) {s4o.print("USINT"); return NULL;} |
|
624 |
void *visit(uint_type_name_c *symbol) {s4o.print("UINT"); return NULL;} |
|
625 |
void *visit(udint_type_name_c *symbol) {s4o.print("UDINT"); return NULL;} |
|
626 |
void *visit(ulint_type_name_c *symbol) {s4o.print("ULINT"); return NULL;} |
|
627 |
void *visit(real_type_name_c *symbol) {s4o.print("REAL"); return NULL;} |
|
628 |
void *visit(lreal_type_name_c *symbol) {s4o.print("LREAL"); return NULL;} |
|
629 |
void *visit(date_type_name_c *symbol) {s4o.print("DATE"); return NULL;} |
|
630 |
void *visit(tod_type_name_c *symbol) {s4o.print("TOD"); return NULL;} |
|
631 |
void *visit(dt_type_name_c *symbol) {s4o.print("DT"); return NULL;} |
|
632 |
void *visit(byte_type_name_c *symbol) {s4o.print("BYTE"); return NULL;} |
|
633 |
void *visit(word_type_name_c *symbol) {s4o.print("WORD"); return NULL;} |
|
634 |
void *visit(lword_type_name_c *symbol) {s4o.print("LWORD"); return NULL;} |
|
635 |
void *visit(dword_type_name_c *symbol) {s4o.print("DWORD"); return NULL;} |
|
636 |
void *visit(string_type_name_c *symbol) {s4o.print("STRING"); return NULL;} |
|
637 |
void *visit(wstring_type_name_c *symbol) {s4o.print("WSTRING"); return NULL;} |
|
638 |
||
639 |
void *visit(safetime_type_name_c *symbol) {s4o.print("TIME"); return NULL;} |
|
640 |
void *visit(safebool_type_name_c *symbol) {s4o.print("BOOL"); return NULL;} |
|
641 |
void *visit(safesint_type_name_c *symbol) {s4o.print("SINT"); return NULL;} |
|
642 |
void *visit(safeint_type_name_c *symbol) {s4o.print("INT"); return NULL;} |
|
643 |
void *visit(safedint_type_name_c *symbol) {s4o.print("DINT"); return NULL;} |
|
644 |
void *visit(safelint_type_name_c *symbol) {s4o.print("LINT"); return NULL;} |
|
645 |
void *visit(safeusint_type_name_c *symbol) {s4o.print("USINT"); return NULL;} |
|
646 |
void *visit(safeuint_type_name_c *symbol) {s4o.print("UINT"); return NULL;} |
|
647 |
void *visit(safeudint_type_name_c *symbol) {s4o.print("UDINT"); return NULL;} |
|
648 |
void *visit(safeulint_type_name_c *symbol) {s4o.print("ULINT"); return NULL;} |
|
649 |
void *visit(safereal_type_name_c *symbol) {s4o.print("REAL"); return NULL;} |
|
650 |
void *visit(safelreal_type_name_c *symbol) {s4o.print("LREAL"); return NULL;} |
|
651 |
void *visit(safedate_type_name_c *symbol) {s4o.print("DATE"); return NULL;} |
|
652 |
void *visit(safetod_type_name_c *symbol) {s4o.print("TOD"); return NULL;} |
|
653 |
void *visit(safedt_type_name_c *symbol) {s4o.print("DT"); return NULL;} |
|
654 |
void *visit(safebyte_type_name_c *symbol) {s4o.print("BYTE"); return NULL;} |
|
655 |
void *visit(safeword_type_name_c *symbol) {s4o.print("WORD"); return NULL;} |
|
656 |
void *visit(safelword_type_name_c *symbol) {s4o.print("LWORD"); return NULL;} |
|
657 |
void *visit(safedword_type_name_c *symbol) {s4o.print("DWORD"); return NULL;} |
|
658 |
void *visit(safestring_type_name_c *symbol) {s4o.print("STRING"); return NULL;} |
|
659 |
void *visit(safewstring_type_name_c *symbol) {s4o.print("WSTRING"); return NULL;} |
|
70 | 660 |
|
1016
91bef6704b44
Add support for functions returning VOID (i.e. non-standard extension, allowing functions that do not return any data)
mjsousa
parents:
1011
diff
changeset
|
661 |
void *visit(void_type_name_c *symbol) {s4o.print("void"); return NULL;} |
91bef6704b44
Add support for functions returning VOID (i.e. non-standard extension, allowing functions that do not return any data)
mjsousa
parents:
1011
diff
changeset
|
662 |
|
70 | 663 |
/********************************/ |
664 |
/* B.1.3.2 - Generic data types */ |
|
665 |
/********************************/ |
|
923
0ad7843d3790
Add support for non standard REF_TO ANY (equivalent to void *)
mjsousa
parents:
919
diff
changeset
|
666 |
/* Currently only used in REF_TO ANY, which is mapped onto (void *) */ |
0ad7843d3790
Add support for non standard REF_TO ANY (equivalent to void *)
mjsousa
parents:
919
diff
changeset
|
667 |
void *visit(generic_type_any_c *symbol) {s4o.print("void"); return NULL;} |
70 | 668 |
|
945
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
669 |
|
70 | 670 |
/********************************/ |
671 |
/* B 1.3.3 - Derived data types */ |
|
672 |
/********************************/ |
|
945
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
673 |
|
860
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
674 |
/* enumerated_type_name '#' identifier */ |
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
675 |
void *visit(enumerated_value_c *symbol) { |
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
676 |
if (NULL == symbol->datatype) { |
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
677 |
debug_c::print(symbol); |
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
678 |
ERROR; |
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
679 |
} |
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
680 |
|
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
681 |
symbol_c *type_name = get_datatype_info_c::get_id(symbol->datatype); |
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
682 |
if (NULL == type_name) { |
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
683 |
ERROR_MSG("C code generator does not currently support anonymous enumerated data types."); |
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
684 |
} |
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
685 |
|
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
686 |
type_name->accept(*this); |
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
687 |
s4o.print("__"); |
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
688 |
symbol->value->accept(*this); |
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
689 |
return NULL; |
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
690 |
} |
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
691 |
|
7669a8d43c11
Code cleanup (part 2): generate_typedecl_c now only prints to POUS.h !
mjsousa
parents:
854
diff
changeset
|
692 |
|
70 | 693 |
/*********************/ |
694 |
/* B 1.4 - Variables */ |
|
695 |
/*********************/ |
|
696 |
void *visit(symbolic_variable_c *symbol) { |
|
697 |
TRACE("symbolic_variable_c"); |
|
698 |
this->print_variable_prefix(); |
|
699 |
symbol->var_name->accept(*this); |
|
700 |
return NULL; |
|
701 |
} |
|
702 |
||
966
cd7fa00ad774
When generating C code, use the const_value of a symbolic_variable when it is used in a subrange.
mjsousa
parents:
958
diff
changeset
|
703 |
/* symbolic_constant_c is used only when a variable is used inside the subrange of an array declaration |
cd7fa00ad774
When generating C code, use the const_value of a symbolic_variable when it is used in a subrange.
mjsousa
parents:
958
diff
changeset
|
704 |
* e.g.: ARRAY [1 .. maxval] OF INT |
cd7fa00ad774
When generating C code, use the const_value of a symbolic_variable when it is used in a subrange.
mjsousa
parents:
958
diff
changeset
|
705 |
* where maxval is a CONSTANT variable. |
cd7fa00ad774
When generating C code, use the const_value of a symbolic_variable when it is used in a subrange.
mjsousa
parents:
958
diff
changeset
|
706 |
* When maxval shows up in the POU body, it will be stored as a standard symbolic_variable_c in the AST. |
cd7fa00ad774
When generating C code, use the const_value of a symbolic_variable when it is used in a subrange.
mjsousa
parents:
958
diff
changeset
|
707 |
* When maxval shows up in the ARRAY declaration, it will be stored as a symbolic_constant_c in the AST. |
cd7fa00ad774
When generating C code, use the const_value of a symbolic_variable when it is used in a subrange.
mjsousa
parents:
958
diff
changeset
|
708 |
* This will allow us to more easily handle this special case, without affecting the remaining working code. |
cd7fa00ad774
When generating C code, use the const_value of a symbolic_variable when it is used in a subrange.
mjsousa
parents:
958
diff
changeset
|
709 |
*/ |
cd7fa00ad774
When generating C code, use the const_value of a symbolic_variable when it is used in a subrange.
mjsousa
parents:
958
diff
changeset
|
710 |
// a non-standard extension!! |
cd7fa00ad774
When generating C code, use the const_value of a symbolic_variable when it is used in a subrange.
mjsousa
parents:
958
diff
changeset
|
711 |
void *visit(symbolic_constant_c *symbol) { |
cd7fa00ad774
When generating C code, use the const_value of a symbolic_variable when it is used in a subrange.
mjsousa
parents:
958
diff
changeset
|
712 |
TRACE("symbolic_variable_c"); |
cd7fa00ad774
When generating C code, use the const_value of a symbolic_variable when it is used in a subrange.
mjsousa
parents:
958
diff
changeset
|
713 |
if (symbol->const_value. _int64.is_valid()) s4o.print(symbol->const_value. _int64.get()); |
cd7fa00ad774
When generating C code, use the const_value of a symbolic_variable when it is used in a subrange.
mjsousa
parents:
958
diff
changeset
|
714 |
else if (symbol->const_value._uint64.is_valid()) s4o.print(symbol->const_value._uint64.get()); |
cd7fa00ad774
When generating C code, use the const_value of a symbolic_variable when it is used in a subrange.
mjsousa
parents:
958
diff
changeset
|
715 |
else ERROR; |
cd7fa00ad774
When generating C code, use the const_value of a symbolic_variable when it is used in a subrange.
mjsousa
parents:
958
diff
changeset
|
716 |
return NULL; |
cd7fa00ad774
When generating C code, use the const_value of a symbolic_variable when it is used in a subrange.
mjsousa
parents:
958
diff
changeset
|
717 |
} |
945
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
718 |
|
70 | 719 |
/********************************************/ |
720 |
/* B.1.4.1 Directly Represented Variables */ |
|
721 |
/********************************************/ |
|
722 |
void *visit(direct_variable_c *symbol) { |
|
723 |
TRACE("direct_variable_c"); |
|
724 |
/* Do not use print_token() as it will change everything into uppercase */ |
|
944
d6d9211e9aab
fix bug introduced a few commits ago: do not print the first char ('%') of a direct_variable_c (e.g. skip % in %IW4.2)
mjsousa
parents:
936
diff
changeset
|
725 |
return s4o.printlocation(symbol->value+1); // '+1' so we do not print the '%' in '%IW3.2' |
70 | 726 |
} |
727 |
||
728 |
||
729 |
/*************************************/ |
|
730 |
/* B.1.4.2 Multi-element Variables */ |
|
731 |
/*************************************/ |
|
732 |
/* subscripted_variable '[' subscript_list ']' */ |
|
945
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
733 |
//SYM_REF2(array_variable_c, subscripted_variable, subscript_list) |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
734 |
|
70 | 735 |
|
736 |
/* record_variable '.' field_selector */ |
|
737 |
/* WARNING: input and/or output variables of function blocks |
|
738 |
* may be accessed as fields of a structured variable! |
|
739 |
* Code handling a structured_variable_c must take |
|
740 |
* this into account! |
|
741 |
*/ |
|
742 |
// SYM_REF2(structured_variable_c, record_variable, field_selector) |
|
936
0f7bcc160568
Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
928
diff
changeset
|
743 |
// TODO: It seems to me this code no longer gets to execute, since the function is overloaded in generate_c_st_c and generate_c_il_c |
0f7bcc160568
Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
928
diff
changeset
|
744 |
// I will have to check this later, and delete this code if the above is really true! |
70 | 745 |
void *visit(structured_variable_c *symbol) { |
746 |
TRACE("structured_variable_c"); |
|
747 |
symbol->record_variable->accept(*this); |
|
748 |
s4o.print("."); |
|
749 |
symbol->field_selector->accept(*this); |
|
750 |
return NULL; |
|
751 |
} |
|
752 |
||
753 |
/******************************************/ |
|
754 |
/* B 1.4.3 - Declaration & Initialisation */ |
|
755 |
/******************************************/ |
|
756 |
/* leave for derived classes... */ |
|
757 |
||
758 |
/**************************************/ |
|
759 |
/* B.1.5 - Program organization units */ |
|
760 |
/**************************************/ |
|
761 |
/***********************/ |
|
762 |
/* B 1.5.1 - Functions */ |
|
763 |
/***********************/ |
|
764 |
/* leave for derived classes... */ |
|
765 |
||
766 |
/*****************************/ |
|
767 |
/* B 1.5.2 - Function Blocks */ |
|
768 |
/*****************************/ |
|
769 |
/* leave for derived classes... */ |
|
770 |
||
771 |
/**********************/ |
|
772 |
/* B 1.5.3 - Programs */ |
|
773 |
/**********************/ |
|
774 |
/* leave for derived classes... */ |
|
775 |
||
776 |
/*********************************************/ |
|
777 |
/* B.1.6 Sequential function chart elements */ |
|
778 |
/*********************************************/ |
|
779 |
||
780 |
/********************************/ |
|
781 |
/* B 1.7 Configuration elements */ |
|
782 |
/********************************/ |
|
783 |
/* leave for derived classes... */ |
|
784 |
||
785 |
/****************************************/ |
|
786 |
/* B.2 - Language IL (Instruction List) */ |
|
787 |
/****************************************/ |
|
788 |
/***********************************/ |
|
789 |
/* B 2.1 Instructions and Operands */ |
|
790 |
/***********************************/ |
|
791 |
/* leave for derived classes... */ |
|
792 |
||
793 |
/*******************/ |
|
794 |
/* B 2.2 Operators */ |
|
795 |
/*******************/ |
|
796 |
/* leave for derived classes... */ |
|
797 |
||
798 |
||
799 |
/***************************************/ |
|
800 |
/* B.3 - Language ST (Structured Text) */ |
|
801 |
/***************************************/ |
|
802 |
/***********************/ |
|
803 |
/* B 3.1 - Expressions */ |
|
804 |
/***********************/ |
|
805 |
/* leave for derived classes... */ |
|
806 |
||
807 |
/********************/ |
|
808 |
/* B 3.2 Statements */ |
|
809 |
/********************/ |
|
810 |
/* leave for derived classes... */ |
|
811 |
||
812 |
/*********************************/ |
|
813 |
/* B 3.2.1 Assignment Statements */ |
|
814 |
/*********************************/ |
|
815 |
/* leave for derived classes... */ |
|
816 |
||
817 |
/*****************************************/ |
|
818 |
/* B 3.2.2 Subprogram Control Statements */ |
|
819 |
/*****************************************/ |
|
820 |
/* leave for derived classes... */ |
|
821 |
||
822 |
/********************************/ |
|
823 |
/* B 3.2.3 Selection Statements */ |
|
824 |
/********************************/ |
|
825 |
/* leave for derived classes... */ |
|
826 |
||
827 |
/********************************/ |
|
828 |
/* B 3.2.4 Iteration Statements */ |
|
829 |
/********************************/ |
|
830 |
/* leave for derived classes... */ |
|
831 |
||
177
697562a5da7c
Adding support for SAFEBOOL. Some code generation yet to do...
mario
parents:
160
diff
changeset
|
832 |
|
70 | 833 |
}; /* class generate_c_basic_c */ |
834 |
||
835 |
||
836 |
||
837 |
||
838 |
||
839 |
||
840 |
||
945
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
841 |
/************************************************************************************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
842 |
/************************************************************************************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
843 |
/************************************************************************************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
844 |
/************************************************************************************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
845 |
/************************************************************************************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
846 |
/************************************************************************************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
847 |
/************************************************************************************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
848 |
/************************************************************************************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
849 |
/************************************************************************************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
850 |
/************************************************************************************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
851 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
852 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
853 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
854 |
/* generate_c_base_and_typeid_c |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
855 |
* ---------------------------- |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
856 |
* This is similar to the generate_c_base_c (from which it inherits), but it also handles |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
857 |
* all the derived datatypes. Note that it does not generate C code for the declaration of |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
858 |
* those datatypes (that is what generate_c_typedecl_c is for), but rather it merely |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
859 |
* generates the name/id of a derived datatype. |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
860 |
* Note too that not all derived datatypes in the IEC 61131-3 have a name (for example, |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
861 |
* VAR a: ARRAY [3..5] of INT END_VAR), in which case an alias for this datatype should |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
862 |
* have been previously generated by either generate_c_typedecl_c or generate_implicit_typedecl_c. |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
863 |
*/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
864 |
class generate_c_base_and_typeid_c: public generate_c_base_c { |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
865 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
866 |
public: |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
867 |
generate_c_base_and_typeid_c(stage4out_c *s4o_ptr): generate_c_base_c(s4o_ptr) {} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
868 |
~generate_c_base_and_typeid_c(void) {} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
869 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
870 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
871 |
/*************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
872 |
/* B.1 - Common elements */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
873 |
/*************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
874 |
/*******************************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
875 |
/* B 1.1 - Letters, digits and identifiers */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
876 |
/*******************************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
877 |
void *visit(derived_datatype_identifier_c *symbol) { |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
878 |
if (get_datatype_info_c::is_array(symbol->datatype)) { |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
879 |
return symbol->datatype->accept(*this); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
880 |
} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
881 |
return print_token(symbol); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
882 |
} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
883 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
884 |
/*********************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
885 |
/* B 1.2 - Constants */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
886 |
/*********************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
887 |
/**********************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
888 |
/* B.1.3 - Data types */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
889 |
/**********************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
890 |
/***********************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
891 |
/* B 1.3.1 - Elementary Data Types */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
892 |
/***********************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
893 |
/********************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
894 |
/* B.1.3.2 - Generic data types */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
895 |
/********************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
896 |
/* Currently only used in REF_TO ANY, which is mapped onto (void *) */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
897 |
void *visit(generic_type_any_c *symbol) {s4o.print("void"); return NULL;} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
898 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
899 |
/********************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
900 |
/* B 1.3.3 - Derived data types */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
901 |
/********************************/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
902 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
903 |
/* subrange_type_name ':' subrange_spec_init */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
904 |
void *visit(subrange_type_declaration_c *symbol) {return symbol->subrange_type_name->accept(*this);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
905 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
906 |
/* subrange_specification ASSIGN signed_integer */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
907 |
void *visit(subrange_spec_init_c *symbol) {return symbol->subrange_specification->accept(*this);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
908 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
909 |
/* integer_type_name '(' subrange')' */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
910 |
void *visit(subrange_specification_c *symbol) {return symbol->integer_type_name->accept(*this);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
911 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
912 |
/* enumerated_type_name ':' enumerated_spec_init */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
913 |
void *visit(enumerated_type_declaration_c *symbol) {return symbol->enumerated_type_name->accept(*this);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
914 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
915 |
/* enumerated_specification ASSIGN enumerated_value */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
916 |
void *visit(enumerated_spec_init_c *symbol) {return symbol->enumerated_specification->accept(*this);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
917 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
918 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
919 |
/* enumerated_type_name '#' identifier */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
920 |
/* Handled by generate_c_base_c class!! |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
921 |
void *visit(enumerated_value_c *symbol) {} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
922 |
*/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
923 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
924 |
/* identifier ':' array_spec_init */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
925 |
void *visit(array_type_declaration_c *symbol) { |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
926 |
int implicit_id_count = symbol->anotations_map.count("generate_c_annotaton__implicit_type_id"); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
927 |
if (1 != implicit_id_count) ERROR; |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
928 |
return symbol->anotations_map["generate_c_annotaton__implicit_type_id"]->accept(*this); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
929 |
} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
930 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
931 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
932 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
933 |
/* array_specification [ASSIGN array_initialization] */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
934 |
/* array_initialization may be NULL ! */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
935 |
void *visit(array_spec_init_c *symbol) { |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
936 |
int implicit_id_count = symbol->anotations_map.count("generate_c_annotaton__implicit_type_id"); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
937 |
if (1 == implicit_id_count) return symbol->anotations_map["generate_c_annotaton__implicit_type_id"]->accept(*this); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
938 |
if (0 == implicit_id_count) return symbol->datatype->accept(*this); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
939 |
return NULL; |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
940 |
} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
941 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
942 |
/* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
943 |
void *visit(array_specification_c *symbol) { |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
944 |
int implicit_id_count = symbol->anotations_map.count("generate_c_annotaton__implicit_type_id"); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
945 |
if (1 != implicit_id_count) ERROR; |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
946 |
return symbol->anotations_map["generate_c_annotaton__implicit_type_id"]->accept(*this); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
947 |
} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
948 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
949 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
950 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
951 |
/* simple_type_name ':' simple_spec_init */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
952 |
void *visit(simple_type_declaration_c *symbol) {return symbol->simple_type_name->accept(*this);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
953 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
954 |
/* simple_specification [ASSIGN constant] */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
955 |
//SYM_REF2(simple_spec_init_c, simple_specification, constant) |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
956 |
// <constant> may be NULL |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
957 |
void *visit(simple_spec_init_c *symbol) {return symbol->simple_specification->accept(*this);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
958 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
959 |
/* structure_type_name ':' structure_specification */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
960 |
//SYM_REF2(structure_type_declaration_c, structure_type_name, structure_specification) |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
961 |
void *visit(structure_type_declaration_c *symbol) {return symbol->structure_type_name->accept(*this);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
962 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
963 |
/* structure_type_name ASSIGN structure_initialization */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
964 |
/* structure_initialization may be NULL ! */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
965 |
//SYM_REF2(initialized_structure_c, structure_type_name, structure_initialization) |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
966 |
void *visit(initialized_structure_c *symbol) {return symbol->structure_type_name->accept(*this);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
967 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
968 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
969 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
970 |
/* ref_spec: REF_TO (non_generic_type_name | function_block_type_name) */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
971 |
// SYM_REF1(ref_spec_c, type_name) |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
972 |
void *visit(ref_spec_c *symbol) { |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
973 |
int implicit_id_count = symbol->anotations_map.count("generate_c_annotaton__implicit_type_id"); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
974 |
if (implicit_id_count > 1) ERROR; |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
975 |
if (implicit_id_count == 1) { |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
976 |
/* this is part of an implicitly declared datatype (i.e. inside a variable decaration), for which an equivalent C datatype |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
977 |
* has already been defined. So, we simly print out the id of that C datatpe... |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
978 |
*/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
979 |
return symbol->anotations_map["generate_c_annotaton__implicit_type_id"]->accept(*this); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
980 |
} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
981 |
/* This is NOT part of an implicitly declared datatype (i.e. we are being called from an visit(ref_type_decl_c *), |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
982 |
* through the visit(ref_spec_init_c*)), so we need to simply print out the name of the datatype we reference to. |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
983 |
*/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
984 |
//debug_c::print(symbol); ERROR; |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
985 |
symbol->type_name->accept(*this); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
986 |
s4o.print("*"); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
987 |
return NULL; |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
988 |
} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
989 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
990 |
/* For the moment, we do not support initialising reference data types */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
991 |
/* ref_spec_init: ref_spec [ ASSIGN ref_initialization ] */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
992 |
/* NOTE: ref_initialization may be NULL!! */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
993 |
// SYM_REF2(ref_spec_init_c, ref_spec, ref_initialization) |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
994 |
void *visit(ref_spec_init_c *symbol) { |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
995 |
/* NOTE An ref_type_decl_c will be created in stage4 for each implicitly defined REF_TO datatype, |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
996 |
* and this generate_c_typedecl_c will be called to define that REF_TO datatype in C. |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
997 |
* However, every implictly defined REF_TO datatype with the exact same parameters will be mapped |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
998 |
* to the same identifier (e.g: __REF_TO_INT). |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
999 |
* In order for the C compiler not to find the same datatype being defined two or more times, |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1000 |
* we will keep track of the datatypes that have already been declared, and henceforth |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1001 |
* only declare the datatypes that have not been previously defined. |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1002 |
*/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1003 |
int implicit_id_count = symbol->anotations_map.count("generate_c_annotaton__implicit_type_id"); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1004 |
if (1 < implicit_id_count) ERROR; |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1005 |
if (1 == implicit_id_count) |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1006 |
return symbol->anotations_map["generate_c_annotaton__implicit_type_id"]->accept(*this); |
958
7474d2cd1d6e
Add a new pou_typename_c object to the AST to store references to previously declared Functions, FB, and Programs.
mjsousa
parents:
947
diff
changeset
|
1007 |
return symbol->ref_spec->accept(*this); // this is probably pointing to an ***_identifier_c !! |
945
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1008 |
} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1009 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1010 |
/* ref_type_decl: identifier ':' ref_spec_init */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1011 |
// SYM_REF2(ref_type_decl_c, ref_type_name, ref_spec_init) |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1012 |
void *visit(ref_type_decl_c *symbol) { |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1013 |
TRACE("ref_type_decl_c"); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1014 |
/* NOTE An ref_type_decl_c will be created in stage4 for each implicitly defined REF_TO datatype, |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1015 |
* and this generate_c_typedecl_c will be called to define that REF_TO datatype in C. |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1016 |
* However, every implictly defined REF_TO datatype with the exact same parameters will be mapped |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1017 |
* to the same identifier (e.g: __REF_TO_INT). |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1018 |
* In order for the C compiler not to find the same datatype being defined two or more times, |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1019 |
* we will keep track of the datatypes that have already been declared, and henceforth |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1020 |
* only declare the datatypes that have not been previously defined. |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1021 |
*/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1022 |
int implicit_id_count = symbol->anotations_map.count("generate_c_annotaton__implicit_type_id"); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1023 |
if (0 != implicit_id_count) ERROR; |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1024 |
//symbol->anotations_map["generate_c_annotaton__implicit_type_id"]->accept(generate_c_base); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1025 |
return symbol->ref_type_name->accept(*this); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1026 |
} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1027 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1028 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1029 |
}; /* class generate_c_base_and_typeid_c */ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1030 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1031 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1032 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1033 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1034 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1035 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1036 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1037 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1038 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1039 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1040 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1041 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
936
diff
changeset
|
1042 |