codegen.cpp.svn-base

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

		if(creators.size()==0)
			fprintf(a, "false");
		else
			for(int i=0; i<creators.size(); i++)
			{
				if(i>0) fprintf(a, " || ");
				fprintf(a, "nn==%d", creators[i]);
			}
		fprintf(a, ";\n");

		fprintf(a, "\t\t}\n");
	}
#endif

	if(data.variables.code_in_parser_class)
		fprintf(a, "\t\t\n\t\t%s\n", data.variables.code_in_parser_class);

	fprintf(a, "\t};\n");
}

template<class T> void generate_single_scalar_constant(FILE *a, char *indent, char *type, char *id, T value, char *format, bool it_is_cpp)
{
	if(!it_is_cpp)
	{
		string s=string("%sstatic const %s %s=")+string(format)+string(";\n");
		fprintf(a, s.c_str(), indent, type, id, value);
	}
	else
		fprintf(a, "%sconst %s %s::Parser::%s;\n", indent, type, data.variables.whale_namespace, id);
}

void generate_scalar_constants(FILE *a, char *indent, bool it_is_cpp)
{
	generate_single_scalar_constant(a, indent, "int", "assumed_number_of_bits_in_int", data.variables.assumed_number_of_bits_in_int, "%u", it_is_cpp);
	generate_single_scalar_constant(a, indent, "int", "number_of_terminals", data.terminals.size(), "%u", it_is_cpp);
	generate_single_scalar_constant(a, indent, "int", "number_of_nonterminals", data.nonterminals.size(), "%u", it_is_cpp);
	generate_single_scalar_constant(a, indent, "int", "number_of_lr_states", data.lr_automaton.states.size(), "%u", it_is_cpp);
	generate_single_scalar_constant(a, indent, "int", "number_of_rules", data.rules.size(), "%u", it_is_cpp);
//	generate_single_scalar_constant(a, indent, "int", "rule_body_table_size", data.tables.rule_bodies.size(), "%u", it_is_cpp);
	if(data.variables.compress_action_table)
		generate_single_scalar_constant(a, indent, "int", "compressed_action_table_size", data.tables.lr_action.size(), "%u", it_is_cpp);
	if(data.variables.using_error_map)
		generate_single_scalar_constant(a, indent, "int", "compressed_action_error_map_size", data.tables.lr_action_error_map.size(), "%u", it_is_cpp);
	if(data.variables.compress_goto_table)
		generate_single_scalar_constant(a, indent, "int", "compressed_goto_table_size", data.tables.lr_goto.size(), "%u", it_is_cpp);
	if(data.variables.generate_table_of_pointers_to_members)
		generate_single_scalar_constant(a, indent, "int", "table_of_pointers_to_members_size", data.tables.all_data_members.size(), "%u", it_is_cpp);
	generate_single_scalar_constant(a, indent, "int", "eof_terminal_number", data.eof_terminal_number, "%u", it_is_cpp);
	generate_single_scalar_constant(a, indent, "int", "error_terminal_number", data.error_terminal_number, "%u", it_is_cpp);
}

void generate_table_of_states(FILE *a)
{
	fprintf(a, "const %s::Parser::StateData %s::Parser::states[%s::Parser::number_of_lr_states]={\n",
		data.variables.whale_namespace,
		data.variables.whale_namespace,
		data.variables.whale_namespace);

	// LR automaton states.
	for(int i=0; i<data.lr_automaton.states.size(); i++)
	{
		LRAutomaton::State &state=data.lr_automaton.states[i];

		if(i) fprintf(a, ",\n");
		fprintf(a, "\t{ ", i);

		if(!data.variables.compress_action_table)
		{
			fprintf(a, "{ ");
			for(int j=0; j<data.terminals.size(); j++)
			{
				if(j) fprintf(a, ", ");
				fprintf(a, "%d", state.action_table[j]);
			}
			fprintf(a, " }");
		}
		else
			generate_index_entry_to_access_compressed_table(a, data.tables.lr_action_indices[i], data.variables.action_table_compression_mode);

		if(data.variables.using_error_map)
		{
			fprintf(a, ", ");
			generate_index_entry_to_access_compressed_table(a, data.tables.lr_action_error_map_indices[i], 1);
		}

		fprintf(a, ", ");

		if(!data.variables.compress_goto_table)
		{
			fprintf(a, "{ ");
			for(int j=0; j<data.nonterminals.size(); j++)
			{
				if(j) fprintf(a, ", ");
				if(state.goto_table[j]!=-1)
					fprintf(a, "%u", state.goto_table[j]);
				else
					fprintf(a, "0");
			}
			fprintf(a, " }");
		}
		else
			generate_index_entry_to_access_compressed_table(a, data.tables.lr_goto_indices[i], data.variables.goto_table_compression_mode);

		fprintf(a, " }");
	}
	fprintf(a, "\n};\n");
}

void generate_index_entry_to_access_compressed_table(FILE *a, IndexEntry &ie, int mode)
{
	if(mode<=2)
		fprintf(a, "%d", ie.offset);
	else if(mode==3)
	{
		if(ie.it_is_offset)
			fprintf(a, "false, %d", ie.offset);
		else
			fprintf(a, "true, %d", ie.value);
	}
}

void generate_table_of_pointers_to_members(FILE *a)
{
	fprintf(a, "%s::Symbol *%s::Nonterminal::*pointers_to_members[%s::Parser::table_of_pointers_to_members_size]={\n",
		data.variables.whale_namespace,
		data.variables.whale_namespace,
		data.variables.whale_namespace);

	for(int i=0; i<data.tables.all_data_members.size(); i++)
	{
		ClassHierarchy::DataMember *dm=data.tables.all_data_members[i];
		if(!dm->type->is_internal) continue;

		if(i) fprintf(a, ",\n");
	//	fprintf(a, "\t(%s *%s::*)&%s", dm->type->get_full_name().c_str(), dm->belongs_to->get_full_name().c_str(), dm->name.c_str());
		fprintf(a, "\t(%s::Symbol *%s::Nonterminal::*)&%s::%s::%s",
			data.variables.whale_namespace,
			data.variables.whale_namespace,
			data.variables.whale_namespace,
			dm->belongs_to->get_full_name().c_str(),
			dm->name.c_str());
	}

	fprintf(a, "\n};\n");
}

void generate_table_of_rules(FILE *a)
{
	fprintf(a, "const %s::Parser::RuleData %s::Parser::rules[%s::Parser::number_of_rules]={\n",
		data.variables.whale_namespace,
		data.variables.whale_namespace,
		data.variables.whale_namespace);

	for(int i=0; i<data.rules.size(); i++)
	{
	#ifdef MAKE_TABLE_OF_RULE_BODIES
		if(i) fprintf(a, ",\n");
	#else
		if(i) fprintf(a, (i%4==0 ? ",\n" : ","));
	#endif

		fprintf(a, "\t{ %u", data.rules[i].nn);

	#ifdef MAKE_TABLE_OF_RULE_BODIES
		if(data.rules[i].body.size())
			fprintf(a, ", rule_bodies%s, %u", printable_increment(data.tables.rule_body_indices[i]), data.rules[i].body.size());
		else
			fprintf(a, ", NULL, 0");
	#else
		if(data.rules[i].body.size())
			fprintf(a, ", %u", data.rules[i].body.size());
		else
			fprintf(a, ", 0");
	#endif
		fprintf(a, " }");
	}

	fprintf(a, "\n};\n");
}

void generate_raw_tables(FILE *a, const char *indent, bool it_is_cpp)
{
#ifdef MAKE_TABLE_OF_RULE_BODIES
	if(!it_is_cpp)
		fprintf(a, "%sstatic const int rule_bodies[rule_body_table_size];\n", indent);
	else
	{
		fprintf(a, "\nconst int %s::Parser::rule_bodies[%s::Parser::rule_body_table_size]={\n",
			data.variables.whale_namespace,
			data.variables.whale_namespace);
		TablePrinter rule_bodies_printer(a, "\t", "%3d", 12);
		rule_bodies_printer.print(data.tables.rule_bodies);
		fprintf(a, "\n};\n");
	}
#endif
	if(data.variables.compress_action_table)
	{
		if(!it_is_cpp)
			fprintf(a, "%sstatic const int compressed_action_table[compressed_action_table_size];\n", indent);
		else
		{
			fprintf(a, "\nconst int %s::Parser::compressed_action_table[%s::Parser::compressed_action_table_size]={\n",
				data.variables.whale_namespace,
				data.variables.whale_namespace);
			TablePrinter action_table_printer(a, "\t", "%3d", 12);
			action_table_printer.print(data.tables.lr_action);
			fprintf(a, "\n};\n");
		}
	}
	if(data.variables.using_error_map)
	{
		if(!it_is_cpp)
			fprintf(a, "%sstatic const unsigned int compressed_action_error_map[compressed_action_error_map_size];\n", indent);
		else
		{
			fprintf(a, "\nconst unsigned int %s::Parser::compressed_action_error_map[%s::Parser::compressed_action_error_map_size]={\n",
				data.variables.whale_namespace,
				data.variables.whale_namespace);
			TablePrinter action_table_printer(a, "\t", "0x%08x", 6);
			action_table_printer.print(data.tables.lr_action_error_map);
			fprintf(a, "\n};\n");
		}
	}
	if(data.variables.compress_goto_table)
	{
		if(!it_is_cpp)
			fprintf(a, "%sstatic const int compressed_goto_table[compressed_goto_table_size];\n", indent);
		else
		{
			fprintf(a, "\nconst int %s::Parser::compressed_goto_table[%s::Parser::compressed_goto_table_size]={\n",
				data.variables.whale_namespace,
				data.variables.whale_namespace);
			TablePrinter goto_table_printer(a, "\t", "%3d", 12);
			goto_table_printer.print(data.tables.lr_goto);
			fprintf(a, "\n};\n");
		}
	}
}

void generate_data_member(ClassHierarchy::DataMember *m, FILE *a, const char *indent)
{
	assert(m && m->type);
	int number_of_iterations=m->number_of_nested_iterations;

	string type_name("");

	for(int i=0; i<number_of_iterations; i++)
		type_name+="std::vector<";

//	cout << "(" << m->type << ", " << m << ") TRYING...";
	type_name+=m->type->name;
//	cout << " Ok.\n";

	if(m->type->is_internal)
		type_name+=" *";

	if(type_name[type_name.size()-1]=='>')
		type_name+=" ";

	for(int i=0; i<number_of_iterations; i++)
		type_name+="> ";

	char c=type_name[type_name.size()-1];
	if(c!='*' && c!='&' && c!=' ')
		type_name+=" ";

	fprintf(a, "%s%s%s;", indent, type_name.c_str(), m->name.c_str());
	if(m->internal_type_if_there_is_an_external_type)
	{
		fprintf(a, " // internal type: %s", m->internal_type_if_there_is_an_external_type->name.c_str());
	}
	fprintf(a, "\n");
}

void generate_single_class(ClassHierarchy::Class *m, FILE *a, const char *indent, int mode)
{
	if(m->is_a_built_in_template)
		return;

	if(mode==1)
	{
		fprintf(a, "%sstruct %s;\n", indent, m->name.c_str());
	}
	else if(mode==2)
	{
		if(m->ancestor)
		{
			fprintf(a, "%sstruct %s : %s", indent, m->name.c_str(), m->ancestor->name.c_str());
			if(m->template_parameters.size())
			{
				for(int i=0; i<m->template_parameters.size(); i++)
				{
					fprintf(a, (!i ? "<" : ", "));
					fprintf(a, "%s", m->template_parameters[i]->get_full_name().c_str());
				}
				fprintf(a, ">\n");
			}
			else
				fprintf(a, "\n");
		}
		else
		{
			assert(!m->template_parameters.size());
			fprintf(a, "%sstruct %s\n", indent, m->name.c_str());
		}
		fprintf(a, "%s{\n", indent);

		string fi_string=string(indent)+string("\t");
		const char *further_indent=fi_string.c_str();

		if(m->in_our_scope.size())
		{
			for(int i=0; i<m->in_our_scope.size(); i++)
				generate_single_class(m->in_our_scope[i], a, further_indent, mode);

			fprintf(a, "%s\n", further_indent);
		}

		if(m->name=="Symbol")
		{
			if (data.variables.generate_visitor || !data.variables.shallow_destructor)
				fprintf(a, "%sSymbol() : next_sibling(0) {}\n", further_indent);

			fprintf(a, "%svirtual bool is_terminal() const =0;\n", further_indent);
			fprintf(a, "%svirtual bool is_nonterminal() const =0;\n", further_indent);
			if (data.variables.generate_visitor)
				fprintf(a, "%svirtual void accept(Visitor &) const =0;\n", further_indent);
			fprintf(a, "%svirtual ~Symbol() {}\n", further_indent);
			if (data.variables.generate_names || data.variables.generate_verbose_prints)
				fprintf(a, "%svirtual const char *symbol_name() const =0;\n", further_indent);
			if (data.variables.xml_support)
				fprintf(a, "%svirtual void write_xml(std::ostream &os, int step=4, int position=0) const =0;\n", further_indent);
			if (data.variables.generate_visitor || !data.variables.shallow_destructor)
				fprintf(a, "\n%sSymbol *next_sibling;\n", further_indent);
		//	if(data.variables.make_up_connection)
		//		fprintf(a, "%s", further_indent);
		}
		else if(m->name=="Terminal")
		{
			fprintf(a, "%sint line, column;\n", further_indent);
			fprintf(a, "%schar *text;\n", further_indent);
			fprintf(a, "%s\n", further_indent);
			fprintf(a, "%svoid print_location(std::ostream &os) const\n", further_indent);
			fprintf(a, "%s{\n", further_indent);
			fprintf(a, "%s\tos << \x22line \x22 << line << \x22 column \x22 << column;\n", further_indent);
			fprintf(a, "%s}\n", further_indent);
			fprintf(a, "%sbool is_terminal() const { return true; }\n", further_indent);
			fprintf(a, "%sbool is_nonterminal() const { return false; }\n", further_indent);
			fprintf(a, "%svirtual int number() const =0;\n", further_indent);

			if(data.variables.generate_visitor)