cprover
Loading...
Searching...
No Matches
statement_list_parser.cpp
Go to the documentation of this file.
1/*******************************************************************\
2
3Module: Statement List Language Parser
4
5Author: Matthias Weiss, matthias.weiss@diffblue.com
6
7\*******************************************************************/
8
11
13
14#include <util/std_code.h>
16
19
20#include <algorithm>
21#include <iostream>
22#include <iterator>
23
25
26extern char *yystatement_listtext;
27
33static irep_idt find_name(const exprt &root)
34{
35 for(const exprt &op : root.operands())
36 {
38 return op.get(ID_value);
39 }
40 UNREACHABLE; // Root expression should always have a name
41}
42
44{
45 const exprt::operandst &ops = tag_list.operands();
47 begin(ops),
48 end(ops),
49 std::back_inserter(parse_tree.tags),
50 static_cast<const symbol_exprt &(*)(const exprt &)>(to_symbol_expr));
51}
52
58static std::string find_version(const exprt &root)
59{
60 for(const exprt &op : root.operands())
61 {
63 {
64 const string_constantt &constant{to_string_constant(op)};
65 return id2string(constant.get_value());
66 }
67 }
68 UNREACHABLE; // Root expression should always have a version
69}
70
76static typet find_return_value(const exprt &root)
77{
80 "Expression ID should be statement_list_function");
81
82 for(const exprt &op : root.operands())
83 {
85 return op.type();
86 }
87
88 UNREACHABLE; // Root expression of FC should always have a return value
89}
90
96static exprt find_variable_list(const exprt &root)
97{
98 for(const exprt &op : root.operands())
99 {
100 if(op.id() == ID_statement_list_var_decls)
101 return op;
102 }
103 UNREACHABLE; // Root expression should always have a variable list
104}
105
113 const exprt &var_list)
114{
115 for(const exprt &entry : var_list.operands())
116 {
117 std::vector<symbol_exprt> symbols;
118 exprt default_value = nil_exprt();
119 for(const exprt &part : entry.operands())
120 {
121 const symbol_exprt *const symbol =
123 if(symbol)
124 symbols.push_back(*symbol);
125 else
126 default_value = part;
127 }
128
129 for(const symbol_exprt &symbol : symbols)
130 {
132 if(default_value.is_not_nil())
133 declaration.default_value = default_value;
134 parse_tree_list.push_back(declaration);
135 }
136 }
137}
138
143static void fill_temp_vars(
145 const exprt &temp_vars)
146{
147 for(const exprt &entry : temp_vars.operands())
148 {
149 for(const exprt &part : entry.operands())
150 {
151 const symbol_exprt *const symbol =
153 if(symbol)
154 {
156 parse_tree_list.push_back(declaration);
157 }
158 else
159 UNREACHABLE; // Temp variables should not have an initial value.
160 }
161 }
162}
163
167static void find_variables(
169 const exprt &var_decls)
170{
171 for(const exprt &decls : var_decls.operands())
172 {
175 else if(decls.id() == ID_statement_list_var_inout)
177 else if(decls.id() == ID_statement_list_var_output)
181 else if(decls.id() == ID_statement_list_var_temp)
182 fill_temp_vars(function.var_temp, decls);
183 }
184}
185
209
215static exprt find_network_list(const exprt &root)
216{
217 for(const exprt &op : root.operands())
218 {
219 if(op.id() == ID_statement_list_networks)
220 return op;
221 }
222 UNREACHABLE; // Root expression should always have a network list
223}
224
229static std::string find_network_title(const exprt &network)
230{
231 for(const exprt &network_element : network.operands())
232 {
234 return network_element.get(ID_value).c_str();
235 }
236 UNREACHABLE; // Network expression should always have a title
237}
238
245{
246 for(const exprt &network_element : network.operands())
247 {
249 return network_element;
250 }
251 UNREACHABLE; // Network expression should always have an instruction list
252}
253
259 const exprt &instructions)
260{
261 for(const exprt &instruction_expr : instructions.operands())
262 {
264
267 for(auto op_it = std::next(instruction_expr.operands().begin());
268 op_it != end(instruction_expr.operands());
269 ++op_it)
270 {
272 label = to_string_constant(*op_it);
273 else if(op_it->is_not_nil())
274 code_token.add_to_operands(*op_it);
275 }
276
277 if(label.get_value() == ID_nil)
278 instruction.add_token(code_token);
279 else
280 instruction.add_token(code_labelt{label.get_value(), code_token});
281
282 network.add_instruction(instruction);
283 }
284}
285
290static void find_networks(
292 const exprt &network_list)
293{
294 for(const exprt &expr_network : network_list.operands())
295 {
296 const std::string title(find_network_title(expr_network));
298 const exprt instructions = find_network_instructions(expr_network);
299 find_instructions(network, instructions);
300 module.add_network(network);
301 }
302}
303
305{
306 INVARIANT(
308 "Root expression ID should be ID_statement_list_function_block");
309
310 // Generate new function block.
312 find_version(block)};
313
314 // Fill the block with networks and variables.
317
319}
320
322{
323 INVARIANT(
324 function.id() == ID_statement_list_function,
325 "Expression ID should be statement_list_function");
326
327 // Generate new function.
329 find_name(function), find_version(function), find_return_value(function)};
330
331 // Fill the function with networks and variables.
334
336}
337
339{
340 return yystatement_listparse() != 0;
341}
342
343int yystatement_listerror(const std::string &error)
344{
346 return 0;
347}
348
354
355void statement_list_parsert::print_tree(std::ostream &out) const
356{
358}
359
static abstract_object_pointert transform(const exprt &expr, const std::vector< abstract_object_pointert > &operands, const abstract_environmentt &environment, const namespacet &ns)
ait supplies three of the four components needed: an abstract interpreter (in this case handling func...
Definition ai.h:563
codet representation of a label for branch targets.
Definition std_code.h:959
Data structure for representing an arbitrary statement in a program.
dstringt has one field, an unsigned integer no which is an index into a static table of strings.
Definition dstring.h:39
Base class for all expressions.
Definition expr.h:56
std::vector< exprt > operandst
Definition expr.h:58
operandst & operands()
Definition expr.h:94
bool is_not_nil() const
Definition irep.h:380
const irep_idt & id() const
Definition irep.h:396
The NIL expression.
Definition std_expr.h:3026
void parse_error(const std::string &message, const std::string &before)
Definition parser.cpp:30
virtual void clear()
Definition parser.h:32
Intermediate representation of a parsed Statement List file before converting it into a goto program.
std::list< var_declarationt > var_declarationst
void clear()
Removes all functions and function blocks from the parse tree.
void add_function_block(function_blockt &block)
Adds a function block to the parse tree.
std::vector< symbol_exprt > tags
List of tags that were included in the source.
void add_function(functiont &function)
Adds a function to the parse tree.
void swap(statement_list_parse_treet &other)
Swaps the contents of the parse tree with the parameter.
Responsible for starting the parse process and to translate the result into a statement_list_parse_tr...
statement_list_parse_treet parse_tree
Tree that is being filled by the parsing process.
void clear() override
Removes all functions and function blocks from the parse tree and clears the internal state of the pa...
void add_tag_list(const exprt &tag_list)
Adds a tag list to the parse tree by converting the tag_list expression tree.
void add_function_block(const exprt &block)
Adds a function block to the parse tree by converting the block expression tree.
void print_tree(std::ostream &out) const
Prints the parse tree of this instance to the given output stream.
void add_function(const exprt &function)
Adds a function to the parse tree by converting the function expression tree.
void swap_tree(statement_list_parse_treet &other)
Swaps the contents of the parse tree of this instance with other.
bool parse() override
Starts the parsing process and saves the result inside of this instance's parse tree.
Expression to hold a symbol (variable)
Definition std_expr.h:113
The type of an expression, extends irept.
Definition type.h:29
std::unordered_set< symbol_exprt, irep_hash > find_variables(const std::vector< exprt > &src)
Returns the set of program variables (as identified by object_address expressions) in the given expre...
const std::string & id2string(const irep_idt &d)
Definition irep.h:47
#define UNREACHABLE
This should be used to mark dead code.
Definition invariant.h:525
#define INVARIANT(CONDITION, REASON)
This macro uses the wrapper function 'invariant_violated_string'.
Definition invariant.h:423
Statement List Language Parse Tree.
void output_parse_tree(std::ostream &out, const statement_list_parse_treet &parse_tree)
Prints the given Statement List parse tree in a human-readable form to the given output stream.
Statement List Language Parse Tree Output.
static void find_variables(statement_list_parse_treet::functiont &function, const exprt &var_decls)
Adds all valid variable declarations to the given function.
static std::string find_version(const exprt &root)
Searches for the version of the TIA module inside of its root expression.
static exprt find_network_instructions(const exprt &network)
Searches for the instruction list of a network inside of its root expression.
static void find_instructions(statement_list_parse_treet::networkt &network, const exprt &instructions)
Adds all valid instructions to the given network.
static void find_networks(statement_list_parse_treet::tia_modulet &module, const exprt &network_list)
Adds all valid networks and their instructions to the given function element.
static exprt find_network_list(const exprt &root)
Searches for the network list of the TIA element inside of its root expression.
statement_list_parsert statement_list_parser
Instance of the parser, used by other modules.
static std::string find_network_title(const exprt &network)
Searches for the title of a network inside of its root expression.
int yystatement_listerror(const std::string &error)
Forwards any errors that are encountered during the parse process.
static exprt find_variable_list(const exprt &root)
Searches for the variable list of the TIA module inside of its root expression.
static irep_idt find_name(const exprt &root)
Searches for the name of the TIA module inside of its root expression.
static void fill_temp_vars(statement_list_parse_treet::var_declarationst &parse_tree_list, const exprt &temp_vars)
Adds all temp variable declarations (variable declarations which can't have a default value) to the g...
static typet find_return_value(const exprt &root)
Searches for the return type of a function inside of its root expression.
char * yystatement_listtext
static void fill_vars_with_default_values(statement_list_parse_treet::var_declarationst &parse_tree_list, const exprt &var_list)
Adds all variable declarations (which can have a default value) to the given list.
Statement List Language Parser.
int yystatement_listparse()
Defined in statement_list_y.tab.cpp.
const multi_ary_exprt & to_multi_ary_expr(const exprt &expr)
Cast an exprt to a multi_ary_exprt.
Definition std_expr.h:932
const symbol_exprt & to_symbol_expr(const exprt &expr)
Cast an exprt to a symbol_exprt.
Definition std_expr.h:222
const string_constantt & to_string_constant(const exprt &expr)
Structure for a simple function block in Statement List.
var_declarationst var_static
FB-exclusive static variable declarations.
Structure for a simple function in Statement List.
Represents a regular Statement List instruction which consists out of one or more codet tokens.
void add_token(const codet &token)
Adds a codet element to the list of all tokens.
Representation of a network in Siemens TIA.
Base element of all modules in the Totally Integrated Automation (TIA) portal by Siemens.
var_declarationst var_constant
Constant variable declarations.
var_declarationst var_input
Input variable declarations.
var_declarationst var_inout
Inout variable declarations.
var_declarationst var_temp
Temp variable declarations.
var_declarationst var_output
Output variable declarations.
Struct for a single variable declaration in Statement List.
optionalt< exprt > default_value
Optional default value of the variable.