statement_list_parser.cpp

Go to the documentation of this file.

/*******************************************************************\
 
Module: Statement List Language Parser
 
Author: Matthias Weiss, matthias.weiss@diffblue.com
 
\*******************************************************************/
 
 
#include "statement_list_parser.h"
 
#include <util/std_code.h>
#include <util/string_constant.h>
 
#include "statement_list_parse_tree.h"
#include "statement_list_parse_tree_io.h"
 
#include <algorithm>
#include <iostream>
#include <iterator>
 
int statement_list_parsert::instance_count = 0;
 
static irep_idt find_name(const exprt &root)
{
  for(const exprt &op : root.operands())
  {
    if(op.get(ID_statement_list_type) == ID_statement_list_identifier)
      return op.get(ID_value);
  }
  UNREACHABLE; // Root expression should always have a name
}
static irep_idt find_name(const exprt &root) {…}
 
void statement_list_parsert::add_tag_list(const exprt &tag_list)
{
  const exprt::operandst &ops = tag_list.operands();
  transform(
    begin(ops),
    end(ops),
    std::back_inserter(parse_tree.tags),
    static_cast<const symbol_exprt &(*)(const exprt &)>(to_symbol_expr));
}
void statement_list_parsert::add_tag_list(const exprt &tag_list) {…}
 
static std::string find_version(const exprt &root)
{
  for(const exprt &op : root.operands())
  {
    if(op.get(ID_statement_list_type) == ID_statement_list_version)
    {
      const string_constantt &constant{to_string_constant(op)};
      return id2string(constant.value());
    }
  }
  UNREACHABLE; // Root expression should always have a version
}
static std::string find_version(const exprt &root) {…}
 
static typet find_return_value(const exprt &root)
{
  INVARIANT(
    root.id() == ID_statement_list_function,
    "Expression ID should be statement_list_function");
 
  for(const exprt &op : root.operands())
  {
    if(op.get(ID_statement_list_type) == ID_statement_list_return)
      return op.type();
  }
 
  UNREACHABLE; // Root expression of FC should always have a return value
}
static typet find_return_value(const exprt &root) {…}
 
static exprt find_variable_list(const exprt &root)
{
  for(const exprt &op : root.operands())
  {
    if(op.id() == ID_statement_list_var_decls)
      return op;
  }
  UNREACHABLE; // Root expression should always have a variable list
}
static exprt find_variable_list(const exprt &root) {…}
 
static void fill_vars_with_default_values(
  statement_list_parse_treet::var_declarationst &parse_tree_list,
  const exprt &var_list)
{
  for(const exprt &entry : var_list.operands())
  {
    std::vector<symbol_exprt> symbols;
    exprt default_value = nil_exprt();
    for(const exprt &part : entry.operands())
    {
      const symbol_exprt *const symbol =
        expr_try_dynamic_cast<symbol_exprt>(part);
      if(symbol)
        symbols.push_back(*symbol);
      else
        default_value = part;
    }
 
    for(const symbol_exprt &symbol : symbols)
    {
      statement_list_parse_treet::var_declarationt declaration{symbol};
      if(default_value.is_not_nil())
        declaration.default_value = default_value;
      parse_tree_list.push_back(declaration);
    }
  }
}
static void fill_vars_with_default_values( {…}
 
static void fill_temp_vars(
  statement_list_parse_treet::var_declarationst &parse_tree_list,
  const exprt &temp_vars)
{
  for(const exprt &entry : temp_vars.operands())
  {
    for(const exprt &part : entry.operands())
    {
      const symbol_exprt *const symbol =
        expr_try_dynamic_cast<symbol_exprt>(part);
      if(symbol)
      {
        statement_list_parse_treet::var_declarationt declaration{*symbol};
        parse_tree_list.push_back(declaration);
      }
      else
        UNREACHABLE; // Temp variables should not have an initial value.
    }
  }
}
static void fill_temp_vars( {…}
 
static void find_variables(
  statement_list_parse_treet::functiont &function,
  const exprt &var_decls)
{
  for(const exprt &decls : var_decls.operands())
  {
    if(decls.id() == ID_statement_list_var_input)
      fill_vars_with_default_values(function.var_input, decls);
    else if(decls.id() == ID_statement_list_var_inout)
      fill_vars_with_default_values(function.var_inout, decls);
    else if(decls.id() == ID_statement_list_var_output)
      fill_vars_with_default_values(function.var_output, decls);
    else if(decls.id() == ID_statement_list_var_constant)
      fill_vars_with_default_values(function.var_constant, decls);
    else if(decls.id() == ID_statement_list_var_temp)
      fill_temp_vars(function.var_temp, decls);
  }
}
static void find_variables( {…}
 
static void find_variables(
  statement_list_parse_treet::function_blockt &block,
  const exprt &var_decls)
{
  for(const exprt &decls : var_decls.operands())
  {
    if(ID_statement_list_var_input == decls.id())
      fill_vars_with_default_values(block.var_input, decls);
    else if(ID_statement_list_var_inout == decls.id())
      fill_vars_with_default_values(block.var_inout, decls);
    else if(ID_statement_list_var_output == decls.id())
      fill_vars_with_default_values(block.var_output, decls);
    else if(ID_statement_list_var_static == decls.id())
      fill_vars_with_default_values(block.var_static, decls);
    else if(ID_statement_list_var_constant == decls.id())
      fill_vars_with_default_values(block.var_constant, decls);
    else if(ID_statement_list_var_temp == decls.id())
      fill_temp_vars(block.var_temp, decls);
  }
}
static void find_variables( {…}
 
static exprt find_network_list(const exprt &root)
{
  for(const exprt &op : root.operands())
  {
    if(op.id() == ID_statement_list_networks)
      return op;
  }
  UNREACHABLE; // Root expression should always have a network list
}
static exprt find_network_list(const exprt &root) {…}
 
static std::string find_network_title(const exprt &network)
{
  for(const exprt &network_element : network.operands())
  {
    if(network_element.get(ID_statement_list_type) == ID_statement_list_title)
      return network_element.get(ID_value).c_str();
  }
  UNREACHABLE; // Network expression should always have a title
}
static std::string find_network_title(const exprt &network) {…}
 
static exprt find_network_instructions(const exprt &network)
{
  for(const exprt &network_element : network.operands())
  {
    if(network_element.id() == ID_statement_list_instructions)
      return network_element;
  }
  UNREACHABLE; // Network expression should always have an instruction list
}
static exprt find_network_instructions(const exprt &network) {…}
 
static void find_instructions(
  statement_list_parse_treet::networkt &network,
  const exprt &instructions)
{
  for(const exprt &instruction_expr : instructions.operands())
  {
    statement_list_parse_treet::instructiont instruction;
 
    codet code_token(to_multi_ary_expr(instruction_expr).op0().id());
    string_constantt label{ID_nil};
    for(auto op_it = std::next(instruction_expr.operands().begin());
        op_it != end(instruction_expr.operands());
        ++op_it)
    {
      if(op_it->get(ID_statement_list_type) == ID_label)
        label = to_string_constant(*op_it);
      else if(op_it->is_not_nil())
        code_token.add_to_operands(*op_it);
    }
 
    if(label.value() == ID_nil)
      instruction.add_token(code_token);
    else
      instruction.add_token(code_labelt{label.value(), code_token});
 
    network.add_instruction(instruction);
  }
}
static void find_instructions( {…}
 
static void find_networks(
  statement_list_parse_treet::tia_modulet &module,
  const exprt &network_list)
{
  for(const exprt &expr_network : network_list.operands())
  {
    const std::string title(find_network_title(expr_network));
    statement_list_parse_treet::networkt network(title);
    const exprt instructions = find_network_instructions(expr_network);
    find_instructions(network, instructions);
    module.add_network(network);
  }
}
static void find_networks( {…}
 
void statement_list_parsert::add_function_block(const exprt &block)
{
  INVARIANT(
    block.id() == ID_statement_list_function_block,
    "Root expression ID should be ID_statement_list_function_block");
 
  // Generate new function block.
  statement_list_parse_treet::function_blockt fb{find_name(block),
                                                 find_version(block)};
 
  // Fill the block with networks and variables.
  find_variables(fb, find_variable_list(block));
  find_networks(fb, find_network_list(block));
 
  parse_tree.add_function_block(fb);
}
void statement_list_parsert::add_function_block(const exprt &block) {…}
 
void statement_list_parsert::add_function(const exprt &function)
{
  INVARIANT(
    function.id() == ID_statement_list_function,
    "Expression ID should be statement_list_function");
 
  // Generate new function.
  statement_list_parse_treet::functiont fn{
    find_name(function), find_version(function), find_return_value(function)};
 
  // Fill the function with networks and variables.
  find_variables(fn, find_variable_list(function));
  find_networks(fn, find_network_list(function));
 
  parse_tree.add_function(fn);
}
void statement_list_parsert::add_function(const exprt &function) {…}
 
int yystatement_listlex_init_extra(statement_list_parsert *, void **);
int yystatement_listlex_destroy(void *);
int yystatement_listparse(statement_list_parsert &, void *);
void yystatement_listset_debug(int, void *);
 
bool statement_list_parsert::parse()
{
  void *scanner;
  yystatement_listlex_init_extra(this, &scanner);
#ifdef STATEMENT_LIST_DEBUG
  yystatement_listset_debug(1, scanner);
#endif
  bool parse_fail = yystatement_listparse(*this, scanner) != 0;
  yystatement_listlex_destroy(scanner);
  return parse_fail;
}
bool statement_list_parsert::parse() {…}
 
void statement_list_parsert::print_tree(std::ostream &out) const
{
  output_parse_tree(out, parse_tree);
}
void statement_list_parsert::print_tree(std::ostream &out) const {…}
 
void statement_list_parsert::swap_tree(statement_list_parse_treet &other)
{
  parse_tree.swap(other);
}
void statement_list_parsert::swap_tree(statement_list_parse_treet &other) {…}