exprtk_truthtable_gen.cpp File Reference

#include <cmath>
#include <cstdio>
#include <string>
#include "exprtk.hpp"

Include dependency graph for exprtk_truthtable_gen.cpp:

Go to the source code of this file.

Functions
template<typename T >
void	truth_table_generator (const std::string &boolean_expression)
int	main (int argc, char *argv[])

Function Documentation

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 159 of file exprtk_truthtable_gen.cpp.

{
   if (2 != argc)
   {
      printf("usage: exprtk_truthtable_gen <expression>\n");
      return 1;
   }
 
   truth_table_generator<double>(argv[1]);
 
   return 0;
}

truth_table_generator()

template<typename T >

void truth_table_generator

(

const std::string &

boolean_expression

)

Definition at line 28 of file exprtk_truthtable_gen.cpp.

{
   typedef exprtk::symbol_table<T>    symbol_table_t;
   typedef exprtk::expression<T>      expression_t;
   typedef exprtk::parser<T>          parser_t;
   typedef exprtk::parser_error::type err_t;
   typedef typename parser_t::settings_store settings_t;
 
   symbol_table_t symbol_table;
 
   expression_t expression;
   expression.register_symbol_table(symbol_table);
 
   static const std::size_t compile_options =
      settings_t::e_replacer            +
      settings_t::e_joiner              +
      settings_t::e_numeric_check       +
      settings_t::e_bracket_check       +
      settings_t::e_sequence_check      +
      settings_t::e_strength_reduction  +
      settings_t::e_disable_usr_on_rsrvd;
 
   parser_t parser(settings_t(compile_options)
                     .disable_all_base_functions    ()
                     .disable_all_control_structures());
 
   parser.enable_unknown_symbol_resolver();
 
   parser.dec().collect_variables() = true;
   parser.dec().collect_functions() = true;
 
   if (!parser.compile(boolean_expression,expression))
   {
      printf("Error: %s\tExpression: %s\n",
             parser.error().c_str(),
             boolean_expression.c_str());
 
      for (std::size_t i = 0; i < parser.error_count(); ++i)
      {
         err_t error = parser.get_error(i);
 
         printf("Error: %02d Position: %02d "
                "Type: [%s] "
                "Message: %s "
                "Expression: %s\n",
                static_cast<int>(i),
                static_cast<int>(error.token.position),
                exprtk::parser_error::to_str(error.mode).c_str(),
                error.diagnostic.c_str(),
                boolean_expression.c_str());
 
         exprtk::parser_error::update_error(error,boolean_expression);
 
         printf("Error[%02d] at line: %d column: %d\n",
                static_cast<int>(i),
                static_cast<int>(error.line_no),
                static_cast<int>(error.column_no));
      }
 
      return;
   }
 
   typedef typename parser_t::dependent_entity_collector::symbol_t dec_symbol_t;
 
   std::deque<dec_symbol_t> symbol_list;
 
   parser.dec().symbols(symbol_list);
 
   if (symbol_list.empty())
   {
      printf("Error: No variables found to build truth table.\n");
      return;
   }
 
   for (std::size_t i = 0; i < symbol_list.size(); ++i)
   {
      if (exprtk::details::imatch(symbol_list[i].first,"not"))
      {
         symbol_list.erase(symbol_list.begin() + i);
 
         if (i >= symbol_list.size())
            break;
      }
 
      if (parser_t::e_st_function == symbol_list[i].second)
      {
         printf("Error: call to function '%s' not allowed.\n",symbol_list[i].first.c_str());
         return;
      }
   }
 
   if (symbol_list.size() > 32)
   {
      printf("Error: no more than 32 unique variables allowed.\n");
      return;
   }
 
   unsigned int upper_bound = 1 << symbol_list.size();
 
   const int index_width = static_cast<int>(std::ceil(std::log10(upper_bound)));
 
   // Print truth table header
   printf(" #%s ",std::string(index_width - 1,' ').c_str());
 
   for (std::size_t i = 0; i < symbol_list.size(); ++i)
   {
      printf("| %s ",symbol_list[i].first.c_str());
   }
 
   printf("| %s \n",boolean_expression.c_str());
 
   for (std::size_t i = 0; i < upper_bound; ++i)
   {
      for (std::size_t j = 0; j < symbol_list.size(); ++j)
      {
         symbol_table.get_variable(symbol_list[j].first)->ref() = T((i & (1 << (symbol_list.size() - j - 1))) ? 0 : 1);
      }
 
      const std::size_t result = static_cast<std::size_t>(expression.value());
 
      printf(" %*d ", index_width, static_cast<int>(i));
 
      for (std::size_t j = 0; j < symbol_list.size(); ++j)
      {
         printf("| %d ",static_cast<int>(symbol_table.get_variable(symbol_list[j].first)->value()));
      }
 
      printf("| %d \n", static_cast<int>(result));
   }
}

References exprtk::details::imatch(), exprtk::parser_error::to_str(), and exprtk::parser_error::update_error().

Here is the call graph for this function: