I am writing a small tool for analyzing simple B Machine substitutions as part of a college research work. The code successfully parse
test inputs of the form mySubst := var1 + var2. However, I get a pop-up error message saying "This application has requested the Runtime to terminate it in an unusual way. " In the command prompt window, I get an "Assertion failed message". The main program is given below:
// BMachineTree.cpp : Defines the entry point for the console application.
//
/*=============================================================================
Copyright (c) 2010 Temitope Onunkun
=============================================================================*/
///////////////////////////////////////////////////////////////////////////////
//
// UUsing
Boost Spririt Trees (AST) to parse B Machine Substitutions.
//
///////////////////////////////////////////////////////////////////////////////
#define BOOST_SPIRIT_DUMP_PARSETREE_AS_XML
#include <boost/spirit/core.hpp>
#include <boost/spirit/tree/ast.hpp>
#include <boost/spirit/tree/tree_to_xml.hpp>
#include "BMachineTreeGrammar.hpp"
#include <iostream>
#include <stack>
#include <functional>
#include <string>
#include <cassert>
#include <vector>
#if defined(BOOST_SPIRIT_DUMP_PARSETREE_AS_XML)
#include <map>
#endif
// Using AST to parse B Machine substitutions
////////////////////////////////////////////////////////////////////////////
using namespace std;
using namespace boost::spirit;
typedef char const* iterator_t;
typedef tree_match<iterator_t> parse_tree_match_t;
typedef parse_tree_match_t::tree_iterator iter_t;
////////////////////////////////////////////////////////////////////////////
string evaluate(parse_tree_match_t hit);
string eval_machine(iter_t const& i);
vector<string> dx;
string evaluate(tree_parse_info<> info)
{
return eval_machine(info.trees.begin());
}
string eval_machine(iter_t const& i)
{
cout << "In eval_machine. i->value = " <<
string(i->value.begin(), i->value.end()) <<
" i->children.size() = " << i->children.size() << endl;
if (i->value.id() == substitution::leafValueID)
{
assert(i->children.size() == 0);
// extract string tokens
string leafValue(i->value.begin(), i->value.end());
dx.push_back(leafValue.c_str());
return leafValue.c_str();
}
//
else if (i->value.id() == substitution::termID)
{
if ( (*i->value.begin() == '*') || (*i->value.begin() == '/') )
{
assert(i->children.size() == 2);
dx.push_back( eval_machine(i->children.begin()) );
dx.push_back( eval_machine(i->children.begin()+1) );
return eval_machine(i->children.begin()) + " " +
eval_machine(i->children.begin()+1);
}
//
else
assert(0);
}
else if (i->value.id() == substitution::expressionID)
{
if ( (*i->value.begin() == '+') || (*i->value.begin() == '-') )
{
assert(i->children.size() == 2);
dx.push_back( eval_machine(i->children.begin()) );
dx.push_back( eval_machine(i->children.begin()+1) );
return eval_machine(i->children.begin()) + " " +
eval_machine(i->children.begin()+1);
}
else
assert(0);
}
//
else if (i->value.id() == substitution::simple_substID)
{
if (*i->value.begin() == (':' >> '=') )
{
assert(i->children.size() == 2);
dx.push_back( eval_machine(i->children.begin()) );
dx.push_back( eval_machine(i->children.begin()+1) );
return eval_machine(i->children.begin()) + "|->" +
eval_machine(i->children.begin()+1);
}
else
assert(0);
}
else
{
assert(0); // error
}
return 0;
}
////////////////////////////////////////////////////////////////////////////
int
main()
{
// look in BMachineTreeGrammar for the definition of BMachine
substitution BMach_subst;
cout << "/////////////////////////////////////////////////////////\n\n";
cout << "\t\tB Machine Substitution...\n\n";
cout << "/////////////////////////////////////////////////////////\n\n";
cout << "Type an expression...or [q or Q] to quit\n\n";
string str;
while (getline(cin, str))
{
if (str.empty() || str[0] == 'q' || str[0] == 'Q')
break;
tree_parse_info<> info = ast_parse(str.c_str(), BMach_subst, space_p);
if (info.full)
{
#if defined(BOOST_SPIRIT_DUMP_PARSETREE_AS_XML)
// dump parse tree as XML
std::map<parser_id, std::string> rule_names;
rule_names[substitution::identifierID] = "identifier";
rule_names[substitution::leafValueID] = "leafValue";
rule_names[substitution::factorID] = "factor";
rule_names[substitution::termID] = "term";
rule_names[substitution::expressionID] = "expression";
rule_names[substitution::simple_substID] = "simple_subst";
tree_to_xml(cout, info.trees, str.c_str(), rule_names);
#endif
// print the result
cout << "Variables in Vector dx: " << endl;
for(vector<string>::iterator idx = dx.begin(); idx < dx.end(); ++idx)
cout << *idx << endl;
cout << "parsing succeeded\n";
cout << "result = " << evaluate(info) << "\n\n";
}
else
{
cout << "parsing failed\n";
}
}
cout << "Bye... :-) \n\n";
return 0;
}
The grammar, defined in BMachineTreeGrammar.hpp file is given below:
/*=============================================================================
Copyright (c) 2010 Temitope Onunkun
http://www.dcs.kcl.ac.uk/pg/onun
Use, modification and distribution is subject to the
Boost Software
License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
http://www.
boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef BOOST_SPIRIT_BMachineTreeGrammar_HPP_
#define BOOST_SPIRIT_BMachineTreeGrammar_HPP_
using namespace boost::spirit;
///////////////////////////////////////////////////////////////////////////////
//
// Using
Boost Spririt Trees (AST) to parse B Machine Substitutions.
//
///////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//
// B Machine Grammar
//
////////////////////////////////////////////////////////////////////////////
struct substitution : public grammar<substitution>
{
static const int identifierID = 1;
static const int leafValueID = 2;
static const int factorID = 3;
static const int termID = 4;
static const int expressionID = 5;
static const int simple_substID = 6;
template <typename ScannerT>
struct definition
{
definition(substitution const& )
{
// Start grammar definition
identifier = alpha_p >> (+alnum_p | ch_p('_') )
;
leafValue = leaf_node_d[
lexeme_d[ identifier | +digit_p ] ]
;
factor = leafValue
| inner_node_d[ ch_p( '(' ) >> expression
>> ch_p(')' ) ]
;
term = factor >>
*( (root_node_d[ch_p('*') ] >> factor )
| (root_node_d[ch_p('/') ] >> factor )
);
expression = term >>
*( (root_node_d[ch_p('+') ] >> term )
| (root_node_d[ch_p('-') ] >> term )
);
simple_subst= leaf_node_d[
lexeme_d[ identifier ] ]
>> root_node_d[str_p(":=")] >> expression
;
// End grammar definition
// turn on the debugging info.
BOOST_SPIRIT_DEBUG_RULE(identifier);
BOOST_SPIRIT_DEBUG_RULE(leafValue);
BOOST_SPIRIT_DEBUG_RULE(factor);
BOOST_SPIRIT_DEBUG_RULE(term);
BOOST_SPIRIT_DEBUG_RULE(expression);
BOOST_SPIRIT_DEBUG_RULE(simple_subst);
}
rule<ScannerT, parser_context<>, parser_tag<simple_substID> > simple_subst;
rule<ScannerT, parser_context<>, parser_tag<expressionID> > expression;
rule<ScannerT, parser_context<>, parser_tag<termID> > term;
rule<ScannerT, parser_context<>, parser_tag<factorID> > factor;
rule<ScannerT, parser_context<>, parser_tag<leafValueID> > leafValue;
rule<ScannerT, parser_context<>, parser_tag<identifierID> > identifier;
rule<ScannerT, parser_context<>, parser_tag<simple_substID> > const&
start() const { return simple_subst; }
};
};
#endif
The output I get on running the program is:
/////////////////////////////////////////////////////////
B Machine Substitution...
/////////////////////////////////////////////////////////
Type an expression...or [q or Q] to quit
mySubst := var1 - var2
parsing succeeded
In eval_machine. i->value = := i->children.size() = 2
Assertion failed: 0, file c:\redmound\bmachinetree\bmachinetree\bmachinetree.cpp
, line 114
I will appreciate any help in resolving this problem.
