variables.cpp.svn-base

Complete support for EBNF notation; Object-oriented parser design; C++ output; Deterministic bottom-

#include "variables.h"
#include "whale.h"
#include "parser.h"
#include "process.h"
#include "utilities.h"
#include "nstl/stl_format.h"
using namespace std;
using namespace Whale;

void report_wrong_parameters(ostream &os, const char *variable, NonterminalOptionStatement *st, const char *additional_text=NULL);
void report_ignored_parameters(ostream &os, const char *variable, NonterminalOptionStatement *st, const char *additional_text=NULL);
bool assign_value_to_id_or_string_variable(char *&variable, char *variable_name);
bool assign_value_to_bool_variable(bool &variable, char *variable_name, bool default_value);
bool assign_value_to_code_variable(char *&variable, char *variable_name);
bool process_parametrized_string(char *&variable, char *variable_name, char *parameters);

Variables::Variables()
{
	whale_namespace=NULL;
	whale_class=NULL;
	lexical_analyzer_file=NULL;
	lexical_analyzer_class=NULL;

	code_in_parser_class=NULL;
	code_in_constructor=NULL;
	code_in_h_before_all=NULL;
	code_in_h=NULL;
	code_in_h_after_all=NULL;
	code_in_cpp_before_all=NULL;
	code_in_cpp=NULL;
	code_in_cpp_after_all=NULL;
	error_handler=NULL;

	// these values are not yet accessible from outside.
	push_null_pointers_to_stack=false;
	rearrange_symbols_between_nested_bodies=true;
	generate_table_of_pointers_to_members=false;
	assumed_number_of_bits_in_int=sizeof(int)*8;
	using_error_map=false; // if needed, it will be set to true elsewhere.
	action_table_compression_mode=3;
	goto_table_compression_mode=2;
	connect_up_operators_are_used=false;
	derive_creators_from_the_abstract_creator=false;
}

Variables::Properties variable_properties(const char *s)
{
	static std::map<const char *, Variables::Properties, NullTerminatedStringCompare> database;
	if(database.size()==0)
	{
		database["whale_namespace"]=Variables::ID_OR_STRING_ALLOWED;
		database["whale_class"]=Variables::ID_OR_STRING_ALLOWED;
		database["lexical_analyzer_file"]=Variables::ID_OR_STRING_ALLOWED;
		database["lexical_analyzer_class"]=Variables::ID_OR_STRING_ALLOWED;
		database["method"]=Variables::ID_ALLOWED;

		database["generate_visitor"]=Variables::TRUE_AND_FALSE_ALLOWED;
		database["get_token_expression"]=Variables::STRING_ALLOWED;
        database["shallow_destructor"]=Variables::TRUE_AND_FALSE_ALLOWED;
        database["generate_names"]=Variables::TRUE_AND_FALSE_ALLOWED;
        database["xml_support"]=Variables::TRUE_AND_FALSE_ALLOWED;

		database["generate_symbols_file"]=Variables::TRUE_AND_FALSE_ALLOWED;

		database["generate_verbose_prints"]=Variables::TRUE_AND_FALSE_ALLOWED;
		database["generate_sanity_checks"]=Variables::TRUE_AND_FALSE_ALLOWED;
		database["push_null_pointers_to_stack"]=Variables::TRUE_AND_FALSE_ALLOWED;
		database["default_member_name_is_nothing"]=Variables::TRUE_AND_FALSE_ALLOWED;
		database["make_up_connection"]=Variables::TRUE_AND_FALSE_ALLOWED;
		database["reuse_iterators"]=Variables::TRUE_AND_FALSE_ALLOWED;
		database["input_queue"]=Variables::TRUE_AND_FALSE_ALLOWED;
		database["line_directives"]=Variables::TRUE_AND_FALSE_ALLOWED;

		database["compress_action_table"]=Variables::TRUE_AND_FALSE_ALLOWED;
		database["compress_goto_table"]=Variables::TRUE_AND_FALSE_ALLOWED;

		database["dump_grammar_to_file"]=Variables::TRUE_AND_FALSE_ALLOWED;
		database["dump_first_to_file"]=Variables::TRUE_AND_FALSE_ALLOWED;
		database["dump_lr_automaton_to_file"]=Variables::TRUE_AND_FALSE_ALLOWED;
		database["dump_conflicts_to_file"]=Variables::TRUE_AND_FALSE_ALLOWED;
		database["dump_precedence_to_file"]=Variables::TRUE_AND_FALSE_ALLOWED;
		database["dump_canonical_conflicts"]=Variables::TRUE_AND_FALSE_ALLOWED;
		database["dump_verbose_conflicts"]=Variables::TRUE_AND_FALSE_ALLOWED;

		database["code_in_class"]=(Variables::Properties)(Variables::CODE_ALLOWED |
			Variables::PARAMETER_ALLOWED | Variables::PARAMETER_REQUIRED |
			Variables::MULTIPLE_ASSIGNMENTS_ALLOWED |
			Variables::SINGLE_ASSIGNMENT_FOR_SINGLE_PARAMETER_LIST);

		database["code_in_h_before_all"]=Variables::CODE_ALLOWED;
		database["code_in_h"]=Variables::CODE_ALLOWED;
		database["code_in_h_after_all"]=Variables::CODE_ALLOWED;
		database["code_in_cpp_before_all"]=Variables::CODE_ALLOWED;
		database["code_in_cpp"]=Variables::CODE_ALLOWED;
		database["code_in_cpp_after_all"]=Variables::CODE_ALLOWED;
		database["code_in_constructor"]=Variables::CODE_ALLOWED;
                database["code_in_destructor"]=Variables::CODE_ALLOWED;
		database["error_handler"]=Variables::CODE_ALLOWED;
	}
	if(database.count(s))
		return database[s];
	else
		return Variables::DOES_NOT_EXIST;
}

bool assign_values_to_variables_stage_zero()
{
	bool flag=true;

	flag=flag & assign_value_to_bool_variable(data.variables.default_member_name_is_nothing,
		"default_member_name_is_nothing", false);

	if(data.assignments.count("make_up_connection"))
	{
		if(assign_value_to_bool_variable(data.variables.make_up_connection, "make_up_connection", false))
		{
			if(data.variables.make_up_connection==false && data.variables.connect_up_operators_are_used)
			{
				cout << "Cannot set make_up_connection=false, because connect_up operators are used.\n";
				flag=false;
			//	data.variables.make_up_connection=true;
			}
		}
		else
			flag=false;
	}
	else
		data.variables.make_up_connection=data.variables.connect_up_operators_are_used;

	// change this.
	data.variables.individual_up_data_members_in_classes=false;
	data.variables.make_creator_lookup_facility=data.variables.make_up_connection;

	// data.variables.derive_creators_from_the_abstract_creator=data.variables.make_up_connection;
	data.variables.derive_creators_from_the_abstract_creator=true;

	return flag;
}

bool assign_values_to_variables_stage_one()
{
	bool flag=true;

	if(data.assignments.count("lexical_analyzer_file"))
		flag=flag & assign_value_to_id_or_string_variable(data.variables.lexical_analyzer_file,
			"lexical_analyzer_file");
	else
		data.variables.lexical_analyzer_file="\x22lexical.h\x22";

	if(data.assignments.count("lexical_analyzer_class"))
		flag=flag & assign_value_to_id_or_string_variable(data.variables.lexical_analyzer_class,
			"lexical_analyzer_class");
	else
		data.variables.lexical_analyzer_class="DolphinLexicalAnalyzer";

	if(data.assignments.count("whale_namespace"))
		flag=flag & assign_value_to_id_or_string_variable(data.variables.whale_namespace,
			"whale_namespace");
	else
		data.variables.whale_namespace="Whale";

	if(data.assignments.count("whale_class"))
		flag=flag & assign_value_to_id_or_string_variable(data.variables.whale_class,
			"whale_class");
	else
		data.variables.whale_class="WhaleParser";

	if(data.assignments.count("method"))
	{
		AssignmentData &ad=data.assignments["method"][0];
		assert(ad.values.size()==1);

		if(!strcmp(ad.values[0].first, "LR1"))
			data.variables.method=Variables::LR1;
		else if(!strcmp(ad.values[0].first, "SLR1"))
			data.variables.method=Variables::SLR1;
		else if(!strcmp(ad.values[0].first, "LALR1"))
			data.variables.method=Variables::LALR1;
		else
		{
			report_wrong_parameters(cout, "method", ad.declaration,
				"expecting 'LR1', 'SLR1' or 'LALR1'");
			flag=false;
		}
	}
	else
		data.variables.method=Variables::LR1;

	if(data.assignments.count("get_token_expression"))
	{
		AssignmentData &ad=data.assignments["get_token_expression"][0];
		assert(ad.values.size()==1);

		std::string s=ad.values[0].first;
		data.variables.get_token_expression=s.substr(1, s.size()-2);
	}
	else
		data.variables.get_token_expression="lexical_analyzer.get_token()";

	flag=flag & assign_value_to_bool_variable(data.variables.shallow_destructor,
		"shallow_destructor", false);
    flag=flag & assign_value_to_bool_variable(data.variables.generate_names,
         "generate_names", false);                                              
    flag=flag & assign_value_to_bool_variable(data.variables.xml_support,
         "xml_support", false);
	flag=flag & assign_value_to_bool_variable(data.variables.generate_symbols_file,
		"generate_symbols_file", false);
	flag=flag & assign_value_to_bool_variable(data.variables.generate_verbose_prints,
		"generate_verbose_prints", false);
	flag=flag & assign_value_to_bool_variable(data.variables.generate_sanity_checks,
		"generate_sanity_checks", false);
	flag=flag & assign_value_to_bool_variable(data.variables.push_null_pointers_to_stack,
		"push_null_pointers_to_stack", false);
	flag=flag & assign_value_to_bool_variable(data.variables.reuse_iterators,
		"reuse_iterators", false);
	flag=flag & assign_value_to_bool_variable(data.variables.input_queue,
		"input_queue", false);

	flag=flag & assign_value_to_bool_variable(data.variables.compress_action_table,
		"compress_action_table", true);
	flag=flag & assign_value_to_bool_variable(data.variables.compress_goto_table,
		"compress_goto_table", true);

	flag=flag & assign_value_to_bool_variable(data.variables.dump_grammar_to_file,
		"dump_grammar_to_file", false);
	flag=flag & assign_value_to_bool_variable(data.variables.dump_first_to_file,
		"dump_first_to_file", false);
	flag=flag & assign_value_to_bool_variable(data.variables.dump_lr_automaton_to_file,
		"dump_lr_automaton_to_file", false);
	flag=flag & assign_value_to_bool_variable(data.variables.dump_conflicts_to_file,
		"dump_conflicts_to_file", true);
	flag=flag & assign_value_to_bool_variable(data.variables.dump_precedence_to_file,
		"dump_precedence_to_file", false);
	flag=flag & assign_value_to_bool_variable(data.variables.dump_canonical_conflicts,
		"dump_canonical_conflicts", false);
	flag=flag & assign_value_to_bool_variable(data.variables.dump_verbose_conflicts,
		"dump_verbose_conflicts", false);


	flag=flag & assign_value_to_code_variable(data.variables.code_in_constructor,
		"code_in_constructor");
        flag=flag & assign_value_to_code_variable(data.variables.code_in_destructor,
                "code_in_destructor");
	flag=flag & assign_value_to_code_variable(data.variables.error_handler,
		"error_handler");

	flag=flag & assign_value_to_code_variable(data.variables.code_in_h_before_all,
		"code_in_h_before_all");
	flag=flag & assign_value_to_code_variable(data.variables.code_in_h,
		"code_in_h");
	flag=flag & assign_value_to_code_variable(data.variables.code_in_h_after_all,
		"code_in_h_after_all");

	flag=flag & assign_value_to_code_variable(data.variables.code_in_cpp_before_all,
		"code_in_cpp_before_all");
	flag=flag & assign_value_to_code_variable(data.variables.code_in_cpp,