cprover
statement_list_parse_tree_io.cpp
Go to the documentation of this file.
1 /*******************************************************************\
2 
3 Module: Statement List Language Parse Tree Output
4 
5 Author: Matthias Weiss, matthias.weiss@diffblue.com
6 
7 \*******************************************************************/
8 
11 
14 
15 #include <util/arith_tools.h>
16 #include <util/bitvector_types.h>
17 #include <util/ieee_float.h>
18 
20 #define NO_VALUE "(none)"
21 
25 static void output_constant(std::ostream &os, const constant_exprt &constant)
26 {
27  mp_integer ivalue;
28  if(!to_integer(constant, ivalue))
29  os << ivalue;
30  else if(can_cast_type<floatbv_typet>(constant.type()))
31  {
32  ieee_floatt real{get_real_type()};
33  real.from_expr(constant);
34  os << real.to_float();
35  }
36  else
37  os << constant.get_value();
38 }
39 
43 static void
44 output_parameter_assignment(std::ostream &os, const equal_exprt &assignment)
45 {
46  os << assignment.lhs().get(ID_identifier) << " := ";
47  const constant_exprt *const constant =
48  expr_try_dynamic_cast<constant_exprt>(assignment.rhs());
49  if(constant)
50  output_constant(os, *constant);
51  else
52  os << assignment.rhs().get(ID_identifier);
53 }
54 
56  std::ostream &out,
57  const statement_list_parse_treet &parse_tree)
58 {
59  for(const auto &function_block : parse_tree.function_blocks)
60  {
61  out << "============== Function Block ==============\n";
62  output_function_block(out, function_block);
63  out << '\n';
64  }
65 
66  for(const auto &function : parse_tree.functions)
67  {
68  out << "================= Function =================\n";
69  output_function(out, function);
70  out << '\n';
71  }
72 
73  if(!parse_tree.tags.empty())
74  {
75  out << "================= Tag List =================\n";
76  for(const auto &tag : parse_tree.tags)
77  {
78  out << tag.pretty();
79  out << '\n';
80  }
81  }
82 }
83 
85  std::ostream &os,
86  const statement_list_parse_treet::function_blockt &function_block)
87 {
88  output_tia_module_properties(function_block, os);
89  output_common_var_declarations(os, function_block);
90  output_static_var_declarations(os, function_block);
91  output_network_list(os, function_block.networks);
92 }
93 
95  std::ostream &os,
97 {
98  output_tia_module_properties(function, os);
99  output_return_value(function, os);
100  output_common_var_declarations(os, function);
101  output_network_list(os, function.networks);
102 }
103 
106  std::ostream &os)
107 {
108  os << "Name: " << module.name << '\n';
109  os << "Version: " << module.version << "\n\n";
110 }
111 
114  std::ostream &os)
115 {
116  os << "Return type: ";
117  if(function.return_type.is_nil())
118  os << "Void";
119  else
120  os << function.return_type.id();
121  os << "\n\n";
122 }
123 
125  std::ostream &os,
127 {
128  if(!module.var_input.empty())
129  {
130  os << "--------- Input Variables ----------\n\n";
132  }
133 
134  if(!module.var_inout.empty())
135  {
136  os << "--------- In/Out Variables ---------\n\n";
138  }
139 
140  if(!module.var_output.empty())
141  {
142  os << "--------- Output Variables ---------\n\n";
144  }
145 
146  if(!module.var_constant.empty())
147  {
148  os << "-------- Constant Variables --------\n\n";
150  }
151 
152  if(!module.var_temp.empty())
153  {
154  os << "---------- Temp Variables ----------\n\n";
156  }
157 }
158 
160  std::ostream &os,
162 {
163  if(!block.var_static.empty())
164  {
165  os << "--------- Static Variables ---------\n\n";
167  }
168 }
169 
171  std::ostream &os,
173 {
174  for(const auto &declaration : declarations)
175  {
176  output_var_declaration(os, declaration);
177  os << "\n\n";
178  }
179 }
180 
182  std::ostream &os,
184 {
185  os << declaration.variable.pretty() << '\n';
186  os << " * default_value: ";
187  if(declaration.default_value)
188  {
189  const constant_exprt &constant =
190  to_constant_expr(declaration.default_value.value());
191  output_constant(os, constant);
192  }
193  else
194  os << NO_VALUE;
195 }
196 
198  std::ostream &os,
200 {
201  os << "-------------- Networks --------------\n\n";
202  for(const auto &network : networks)
203  {
204  output_network(os, network);
205  os << '\n';
206  }
207 }
208 
210  std::ostream &os,
212 {
213  os << "Title: " << network.title.value_or(NO_VALUE) << '\n';
214  os << "Instructions: ";
215  if(network.instructions.empty())
216  os << NO_VALUE;
217  os << '\n';
218  for(const auto &instruction : network.instructions)
219  {
220  output_instruction(os, instruction);
221  os << '\n';
222  }
223 }
224 
226  std::ostream &os,
227  const statement_list_parse_treet::instructiont &instruction)
228 {
229  for(const codet &token : instruction.tokens)
230  {
231  os << token.get_statement();
232  for(const auto &expr : token.operands())
233  {
234  const symbol_exprt *const symbol =
235  expr_try_dynamic_cast<symbol_exprt>(expr);
236  if(symbol)
237  {
238  os << '\t' << symbol->get_identifier();
239  continue;
240  }
241  const constant_exprt *const constant =
242  expr_try_dynamic_cast<constant_exprt>(expr);
243  if(constant)
244  {
245  os << '\t';
246  output_constant(os, *constant);
247  continue;
248  }
249  const equal_exprt *const equal = expr_try_dynamic_cast<equal_exprt>(expr);
250  if(equal)
251  {
252  os << "\n\t";
253  output_parameter_assignment(os, *equal);
254  continue;
255  }
256  os << '\t' << expr.id();
257  }
258  }
259 }
ieee_floatt
Definition: ieee_float.h:120
statement_list_parse_treet::var_declarationt::default_value
optionalt< exprt > default_value
Optional default value of the variable.
Definition: statement_list_parse_tree.h:34
output_return_value
void output_return_value(const statement_list_parse_treet::functiont &function, std::ostream &os)
Prints the return value of a function to the given output stream.
Definition: statement_list_parse_tree_io.cpp:112
binary_exprt::rhs
exprt & rhs()
Definition: std_expr.h:590
arith_tools.h
statement_list_parse_treet::tia_modulet::networks
networkst networks
List of all networks of this module.
Definition: statement_list_parse_tree.h:99
statement_list_parse_treet::networkst
std::list< networkt > networkst
Definition: statement_list_parse_tree.h:76
statement_list_parse_treet::var_declarationst
std::list< var_declarationt > var_declarationst
Definition: statement_list_parse_tree.h:40
irept::pretty
std::string pretty(unsigned indent=0, unsigned max_indent=0) const
Definition: irep.cpp:501
statement_list_parse_treet::tia_modulet::version
const std::string version
Version of the module.
Definition: statement_list_parse_tree.h:85
statement_list_parse_treet::tia_modulet::var_temp
var_declarationst var_temp
Temp variable declarations.
Definition: statement_list_parse_tree.h:94
mp_integer
BigInt mp_integer
Definition: mp_arith.h:19
statement_list_parse_treet::var_declarationt
Struct for a single variable declaration in Statement List.
Definition: statement_list_parse_tree.h:30
statement_list_parse_treet::tia_modulet::var_input
var_declarationst var_input
Input variable declarations.
Definition: statement_list_parse_tree.h:88
binary_exprt::lhs
exprt & lhs()
Definition: std_expr.h:580
statement_list_parse_treet::instructiont
Represents a regular Statement List instruction which consists out of one or more codet tokens.
Definition: statement_list_parse_tree.h:45
statement_list_parse_treet::tia_modulet
Base element of all modules in the Totally Integrated Automation (TIA) portal by Siemens.
Definition: statement_list_parse_tree.h:81
to_integer
bool to_integer(const constant_exprt &expr, mp_integer &int_value)
Convert a constant expression expr to an arbitrary-precision integer.
Definition: arith_tools.cpp:20
statement_list_parse_treet::var_declarationt::variable
symbol_exprt variable
Representation of the variable, including identifier and type.
Definition: statement_list_parse_tree.h:32
symbol_exprt
Expression to hold a symbol (variable)
Definition: std_expr.h:80
equal_exprt
Equality.
Definition: std_expr.h:1139
output_parameter_assignment
static void output_parameter_assignment(std::ostream &os, const equal_exprt &assignment)
Prints the assignment of a module parameter to the given output stream.
Definition: statement_list_parse_tree_io.cpp:44
statement_list_parse_treet::function_blockt
Structure for a simple function block in Statement List.
Definition: statement_list_parse_tree.h:148
output_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.
Definition: statement_list_parse_tree_io.cpp:55
output_common_var_declarations
void output_common_var_declarations(std::ostream &os, const statement_list_parse_treet::tia_modulet &module)
Prints all variable declarations functions and function blocks have in common to the given output str...
Definition: statement_list_parse_tree_io.cpp:124
exprt::type
typet & type()
Return the type of the expression.
Definition: expr.h:82
output_instruction
void output_instruction(std::ostream &os, const statement_list_parse_treet::instructiont &instruction)
Prints the given Statement List instruction in a human-readable form to the given output stream.
Definition: statement_list_parse_tree_io.cpp:225
statement_list_parse_tree_io.h
Statement List Language Parse Tree Output.
statement_list_parse_treet::tia_modulet::var_constant
var_declarationst var_constant
Constant variable declarations.
Definition: statement_list_parse_tree.h:96
symbol_exprt::get_identifier
const irep_idt & get_identifier() const
Definition: std_expr.h:109
statement_list_parse_treet::function_blocks
function_blockst function_blocks
List of function blocks this parse tree includes.
Definition: statement_list_parse_tree.h:174
statement_list_parse_treet::tia_modulet::name
const irep_idt name
Name of the module.
Definition: statement_list_parse_tree.h:83
bitvector_types.h
Pre-defined bitvector types.
output_var_declaration
void output_var_declaration(std::ostream &os, const statement_list_parse_treet::var_declarationt &declaration)
Prints the given Statement List variable declaration in a human-readable form to the given output str...
Definition: statement_list_parse_tree_io.cpp:181
output_var_declaration_list
void output_var_declaration_list(std::ostream &os, const statement_list_parse_treet::var_declarationst &declarations)
Prints all variable declarations of the given list to the given output stream.
Definition: statement_list_parse_tree_io.cpp:170
statement_list_parse_treet::instructiont::tokens
std::vector< codet > tokens
Data structure for all tokens of the instruction.
Definition: statement_list_parse_tree.h:47
statement_list_parse_treet::networkt::instructions
instructionst instructions
Definition: statement_list_parse_tree.h:62
output_static_var_declarations
void output_static_var_declarations(std::ostream &os, const statement_list_parse_treet::function_blockt &block)
Prints the static variable declarations of a function block to the given output stream.
Definition: statement_list_parse_tree_io.cpp:159
statement_list_parse_treet::networkt::title
optionalt< std::string > title
Definition: statement_list_parse_tree.h:61
statement_list_parse_treet::function_blockt::var_static
var_declarationst var_static
FB-exclusive static variable declarations.
Definition: statement_list_parse_tree.h:150
output_network_list
void output_network_list(std::ostream &os, const statement_list_parse_treet::networkst &networks)
Prints the given network list in a human-readable form to the given output stream.
Definition: statement_list_parse_tree_io.cpp:197
statement_list_parse_treet
Intermediate representation of a parsed Statement List file before converting it into a goto program.
Definition: statement_list_parse_tree.h:22
statement_list_parse_treet::tags
std::vector< symbol_exprt > tags
List of tags that were included in the source.
Definition: statement_list_parse_tree.h:178
irept::get
const irep_idt & get(const irep_namet &name) const
Definition: irep.cpp:51
ieee_float.h
output_constant
static void output_constant(std::ostream &os, const constant_exprt &constant)
Prints a constant to the given output stream.
Definition: statement_list_parse_tree_io.cpp:25
NO_VALUE
#define NO_VALUE
String to indicate that there is no value.
Definition: statement_list_parse_tree_io.cpp:20
output_tia_module_properties
void output_tia_module_properties(const statement_list_parse_treet::tia_modulet &module, std::ostream &os)
Prints the basic information about a TIA module to the given output stream.
Definition: statement_list_parse_tree_io.cpp:104
get_real_type
floatbv_typet get_real_type()
Creates a new type that resembles the 'Real' type of the Siemens PLC languages.
Definition: statement_list_types.cpp:25
output_function_block
void output_function_block(std::ostream &os, const statement_list_parse_treet::function_blockt &function_block)
Prints the given Statement List function block in a human-readable form to the given output stream.
Definition: statement_list_parse_tree_io.cpp:84
exprt::operands
operandst & operands()
Definition: expr.h:96
output_function
void output_function(std::ostream &os, const statement_list_parse_treet::functiont &function)
Prints the given Statement List function in a human-readable form to the given output stream.
Definition: statement_list_parse_tree_io.cpp:94
statement_list_parse_treet::tia_modulet::var_inout
var_declarationst var_inout
Inout variable declarations.
Definition: statement_list_parse_tree.h:90
statement_list_parse_treet::functiont
Structure for a simple function in Statement List.
Definition: statement_list_parse_tree.h:129
statement_list_parse_treet::tia_modulet::var_output
var_declarationst var_output
Output variable declarations.
Definition: statement_list_parse_tree.h:92
codet::get_statement
const irep_idt & get_statement() const
Definition: std_code.h:71
constant_exprt
A constant literal expression.
Definition: std_expr.h:2667
output_network
void output_network(std::ostream &os, const statement_list_parse_treet::networkt &network)
Prints the given Statement List network in a human-readable form to the given output stream.
Definition: statement_list_parse_tree_io.cpp:209
constant_exprt::get_value
const irep_idt & get_value() const
Definition: std_expr.h:2675
can_cast_type< floatbv_typet >
bool can_cast_type< floatbv_typet >(const typet &type)
Check whether a reference to a typet is a floatbv_typet.
Definition: bitvector_types.h:354
statement_list_parse_treet::functions
functionst functions
List of functions this parse tree includes.
Definition: statement_list_parse_tree.h:176
statement_list_parse_treet::networkt
Representation of a network in Siemens TIA.
Definition: statement_list_parse_tree.h:60
statement_list_types.h
Statement List Type Helper.
codet
Data structure for representing an arbitrary statement in a program.
Definition: std_code.h:35
to_constant_expr
const constant_exprt & to_constant_expr(const exprt &expr)
Cast an exprt to a constant_exprt.
Definition: std_expr.h:2700