variables.cpp

Full support for extended regular expressions (those with intersection and complement); Support for

#include <stdio.h>
#include "variables.h"
#include "dolphin.h"
#include "process.h"
#include "stl.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 assign_value_to_semibool_variable(int &variable, char *variable_name, int max_value, int true_value);
bool assign_value_to_int_variable(int &variable, char *variable_name);
bool assign_value_to_code_variable(char *&variable, char *variable_name);
bool process_parametrized_string(char *&variable, char *variable_name, char *parameters);

Variables::Variables() :
	my_new_variable(database, "my_new_variable", TRUE_AND_FALSE_ALLOWED),
	another_variable(database, "another_variable", STRING_ALLOWED)
{
	start_conditions_enabled=true;
	compress_action_vectors=false;
	
	generate_fixed_length_lookahead_support=false;
	generate_arbitrary_lookahead_support=false;
	generate_eof_lookahead_support=false;
	
	generate_table_of_actions=false;
	using_layer2=true;
}

bool variable_exists(char *s)
{
	static std::set<char *, NullTerminatedStringCompare> database;
	if(!database.size())
	{
		database.insert("alphabet_cardinality");
		database.insert("unicode");
		database.insert("internal_char_type");
		database.insert("internal_string_type");
		
		database.insert("whale");
		database.insert("whale_file");
		database.insert("whale_namespace");
		database.insert("language");
		database.insert("eat_character_upon_error");
		database.insert("dolphin_class");
		database.insert("generate_verbose_prints");
		database.insert("generate_sanity_checks");
		database.insert("store_lexeme_in_string");
		database.insert("append_data_member");
		database.insert("case_insensitive");
		database.insert("line_directives");
		database.insert("allow_inclusion_cycle_between_whale_and_dolphin");
		
		database.insert("dump_nfa_to_file");
		database.insert("dump_nfas_for_expressions");
		database.insert("dump_nfas_for_start_conditions");
		database.insert("dump_dfas_for_start_conditions");
		database.insert("dump_dfa_to_file");
		
		database.insert("compress_tables");
		database.insert("table_compression_exception_width");
		
		database.insert("input_stream_class");
		database.insert("input_character_class");
		database.insert("how_to_get_actual_character");
		database.insert("how_to_check_eof");
		database.insert("how_to_check_stream_error");
		database.insert("how_to_get_character_from_stream");
		database.insert("how_to_return_token");
		database.insert("analyzer_state_type");
		database.insert("get_token_function_return_value");
		database.insert("get_token_function_parameters");
		
		database.insert("code_in_h_before_all");
		database.insert("code_in_h");
		database.insert("code_in_h_after_all");
		database.insert("code_in_cpp_before_all");
		database.insert("code_in_cpp");
		database.insert("code_in_cpp_after_all");
		database.insert("code_in_class_before_all");
		database.insert("code_in_class");
		database.insert("code_in_class_after_all");
		database.insert("code_in_constructor");
	}
	return database.count(s);
}

bool assign_values_to_variables_stage_zero()
{
	bool flag=true;
	
	if(data.assignments.count("unicode"))
	{
		flag=flag & assign_value_to_bool_variable(data.variables.unicode,
			"unicode");
	}
	else
		data.variables.unicode=false;

	if(data.assignments.count("alphabet_cardinality"))
	{
		flag=flag & assign_value_to_int_variable(data.variables.alphabet_cardinality,
			"alphabet_cardinality");
	}
	else
		data.variables.alphabet_cardinality=(data.variables.unicode ? 4096 /* those who want more should specify it themselves */ : 256);
	
	return flag;
}

bool assign_values_to_variables_stage_one()
{
	// We have the following sources to consider (arranged from the highest
	// priority to the lowest):
	// i. Command line options (not implemented yet)
	// ii. Assignment statements within the source file.
	// iii. Default values.
	
	bool flag=true;
	
	if(data.assignments.count("internal_char_type"))
		flag=flag & assign_value_to_id_or_string_variable(data.variables.internal_char_type,
			"internal_char_type");
	else
		data.variables.internal_char_type=const_cast<char *>(data.variables.unicode ? "wchar_t" : "char");
	
	data.variables.internal_char_type_is_char=(strcmp(data.variables.internal_char_type, "char")==0);
	data.variables.internal_char_type_is_wchar_t=(strcmp(data.variables.internal_char_type, "wchar_t")==0);
	
	if(data.assignments.count("internal_string_type"))
		flag=flag & assign_value_to_id_or_string_variable(data.variables.internal_string_type,
			"internal_string_type");
	else
	{
		if(data.variables.internal_char_type_is_char)
			data.variables.internal_string_type="std::string";
		else if(data.variables.internal_char_type_is_wchar_t)
			data.variables.internal_string_type="std::wstring";
		else
		{
			data.variables.internal_string_type=new char[30+strlen(data.variables.internal_char_type)];
			sprintf(data.variables.internal_string_type, "std::basic_string<%s>", data.variables.internal_char_type);
		}
	}
	
	if(data.assignments.count("whale"))
	{
		AssignmentData &ad=data.assignments["whale"];
		int n=ad.values.size();
		
		if(n==1 && ad.values[0].second==AssignmentData::VALUE_TRUE)
		{
			data.variables.using_whale=true;
			data.variables.whale_emulation_mode=false;
		}
		else if(n==1 && ad.values[0].second==AssignmentData::VALUE_FALSE)
		{
			data.variables.using_whale=false;
			data.variables.whale_emulation_mode=false;
		}
		else if(n==1 && !strcmp(ad.values[0].first, "emulate"))
		{
			data.variables.using_whale=true;
			data.variables.whale_emulation_mode=true;
		}
		else
		{
			report_wrong_parameters(cout, "whale", ad.declaration,
				"expecting 'true', 'false' or 'emulate'");
			flag=false;
		}
	}
	else
	{
		data.variables.using_whale=true;
		data.variables.whale_emulation_mode=false;
	}
	
	if(data.assignments.count("whale_file"))
	{
		if(data.variables.using_whale)
			flag=flag & assign_value_to_id_or_string_variable(data.variables.whale_file,
				"whale_file");
		else
			report_ignored_parameters(cout, "whale_file",
				data.assignments["whale_file"].declaration);
	}
	else
		data.variables.whale_file="parser.h";
	
	if(data.assignments.count("whale_namespace"))
	{
		if(data.variables.using_whale)
			flag=flag & assign_value_to_id_or_string_variable(data.variables.whale_namespace,
				"whale_namespace");
		else
			report_ignored_parameters(cout, "whale_namespace",
				data.assignments["whale_namespace"].declaration);
	}
	else
		data.variables.whale_namespace="Whale";
	
	if(data.assignments.count("language"))
	{
		AssignmentData &ad=data.assignments["language"];
		int n=ad.values.size();
		
		if(n==1 && !strcmp(ad.values[0].first, "cpp"))
			data.variables.output_language=Variables::LANGUAGE_CPP;
		else if(n==1 && !strcmp(ad.values[0].first, "vintage_cpp"))
			data.variables.output_language=Variables::LANGUAGE_VINTAGE_CPP;
		else
		{
			report_wrong_parameters(cout, "language", ad.declaration,
				"expecting 'cpp' or 'vintage_cpp'");
			flag=false;
		}
	}
	else
		data.variables.output_language=Variables::LANGUAGE_CPP;
	
	if(data.assignments.count("dolphin_class"))
		flag=flag & assign_value_to_id_or_string_variable(data.variables.dolphin_class_name,
			"dolphin_class");
	else
		data.variables.dolphin_class_name="DolphinLexicalAnalyzer";
	
	if(data.assignments.count("get_token_function_return_value"))
		flag=flag & assign_value_to_id_or_string_variable(data.variables.get_token_function_return_value,
			"get_token_function_return_value");
	else
	{
		if(data.variables.using_whale)
		{
			string str=string(data.variables.whale_namespace)+string("::Terminal *");
			data.variables.get_token_function_return_value=strdup(str.c_str());
		}
		else
			data.variables.get_token_function_return_value="int";
	}
	
	if(data.assignments.count("get_token_function_parameters"))
	{
		flag=flag & assign_value_to_id_or_string_variable(data.variables.get_token_function_parameters,
			"get_token_function_parameters");
		if(!strcmp(data.variables.get_token_function_parameters, "void"))
			data.variables.get_token_function_parameters="";
	}
	else
		data.variables.get_token_function_parameters="";
	
	if(data.assignments.count("generate_verbose_prints"))
		flag=flag & assign_value_to_bool_variable(data.variables.generate_verbose_prints,
			"generate_verbose_prints");
	else
		data.variables.generate_verbose_prints=false;
	
	if(data.assignments.count("generate_sanity_checks"))
		flag=flag & assign_value_to_bool_variable(data.variables.generate_sanity_checks,
			"generate_sanity_checks");
	else
		data.variables.generate_sanity_checks=false;
	
	if(data.assignments.count("eat_character_upon_error"))
		flag=flag & assign_value_to_bool_variable(data.variables.eat_one_character_upon_lexical_error,
			"eat_character_upon_error");
	else
		data.variables.eat_one_character_upon_lexical_error=true;
	
	if(data.assignments.count("append_data_member"))
		flag=flag & assign_value_to_bool_variable(data.variables.append_data_member,
			"append_data_member");
	else
		data.variables.append_data_member=false;
	
	if(data.assignments.count("case_insensitive"))
		flag=flag & assign_value_to_bool_variable(data.variables.case_insensitive,
			"case_insensitive");
	else
		data.variables.case_insensitive=false;
	
	if(data.assignments.count("compress_tables"))
		flag=flag & assign_value_to_bool_variable(data.variables.compress_tables,
			"compress_tables");
	else
		data.variables.compress_tables=true;
	
	if(data.assignments.count("line_directives"))
		flag=flag & assign_value_to_bool_variable(data.variables.line_directives,
			"line_directives");
	else
		data.variables.line_directives=false;
	
	if(data.assignments.count("allow_inclusion_cycle_between_whale_and_dolphin"))
		flag=flag & assign_value_to_bool_variable(data.variables.allow_inclusion_cycle_between_whale_and_dolphin,
			"allow_inclusion_cycle_between_whale_and_dolphin");
	else
		data.variables.allow_inclusion_cycle_between_whale_and_dolphin=true;
	
	if(data.assignments.count("dump_nfa_to_file"))
		flag=flag & assign_value_to_semibool_variable(data.variables.dump_nfa_to_file,
			"dump_nfa_to_file", 2, 2);
	else
		data.variables.dump_nfa_to_file=0;
	
	if(data.assignments.count("dump_dfa_to_file"))
		flag=flag & assign_value_to_semibool_variable(data.variables.dump_dfa_to_file,
			"dump_dfa_to_file", 2, 2);
	else
		data.variables.dump_dfa_to_file=0;
	
	if(data.assignments.count("dump_nfas_for_expressions"))
		flag=flag & assign_value_to_bool_variable(data.variables.dump_nfas_for_expressions,
			"dump_nfas_for_expressions");
	else
		data.variables.dump_nfas_for_expressions=false;
	
	if(data.assignments.count("dump_nfas_for_start_conditions"))
		flag=flag & assign_value_to_bool_variable(data.variables.dump_nfas_for_start_conditions,
			"dump_nfas_for_start_conditions");
	else
		data.variables.dump_nfas_for_start_conditions=false;
	
	if(data.assignments.count("dump_dfas_for_start_conditions"))
		flag=flag & assign_value_to_bool_variable(data.variables.dump_dfas_for_start_conditions,
			"dump_dfas_for_start_conditions");
	else
		data.variables.dump_dfas_for_start_conditions=false;

	if(data.assignments.count("table_compression_exception_width"))
	{
		flag=flag & assign_value_to_int_variable(data.variables.table_compression_exception_width,
			"table_compression_exception_width");
	}
	else
		data.variables.table_compression_exception_width=1;
	
	if(data.assignments.count("store_lexeme_in_string"))
		flag=flag & assign_value_to_bool_variable(data.variables.store_lexeme_in_string,
			"store_lexeme_in_string");
	else
	{
		if(data.variables.append_data_member)
			data.variables.store_lexeme_in_string=true;
		else
			data.variables.store_lexeme_in_string=false;
	}
	
	if(data.variables.append_data_member && !data.variables.store_lexeme_in_string)
	{
		cout << "Warning: append_data_member=true together with "
			"store_lexeme_in_string=false can potentially lead "
			"to quadratic time complexity.\n";
	//	cout << "The current version of Dolphin requires "
	//		"store_lexeme_in_string to be true if "
	//		"append_data_member=true.\n";
	//	flag=false;
	}
	
	if(data.assignments.count("input_stream_class"))
		flag=flag & assign_value_to_id_or_string_variable(data.variables.input_stream_class,
			"input_stream_class");
	else
	{
		if(data.variables.internal_char_type_is_char)
			data.variables.input_stream_class="std::istream";
		else if(data.variables.internal_char_type_is_wchar_t)
			data.variables.input_stream_class="std::wistream";
		else
		{
			data.variables.input_stream_class=new char[30+strlen(data.variables.internal_char_type)];
			sprintf(data.variables.input_stream_class, "std::basic_ifstream<%s>", data.variables.internal_char_type);