codegen.cpp.svn-base

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

	{
		fprintf(cpp_file, "\t\tinput_symbols.pop();\n");
		fprintf(cpp_file, "\t\tif(input_symbols.empty()) {\n\tinput_symbols.push(%s);\n", data.variables.get_token_expression.c_str());
		if (data.variables.generate_verbose_prints) {
			fprintf(cpp_file, "\t\t#if WHALE_DEBUG != 0\n");
			fprintf(cpp_file, "\t\tif (m_debug)\n");
			fprintf(cpp_file, "\t\t\tcout << \x22read token \\x22\x22 << "
					"input_symbols.back()->symbol_name() << \x22\\x22\\n\x22;\n}\n");
			fprintf(cpp_file, "\t\t#endif\n");
		}
		else
			fprintf(cpp_file, "\t\tif(input_symbols.empty()) {input_symbols.push(%s);\n", data.variables.get_token_expression.c_str());
	}
	fprintf(cpp_file, "\t}\n");

	fprintf(cpp_file, "\t\n");
#if 0
	fprintf(cpp_file, "\tTerminal *t=dynamic_cast<Terminal *>(error_token->garbage[error_token->error_position]);\n");
	if(data.variables.generate_sanity_checks)
		fprintf(cpp_file, "\tif(t==NULL) throw \x22Whale: internal malfunction in error recovery\x22;\n");
	fprintf(cpp_file, "\terror_token->line=t->line;\n");
	fprintf(cpp_file, "\terror_token->column=t->column;\n");
	fprintf(cpp_file, "\t\n");
	fprintf(cpp_file, "\treturn true;\n");
#endif
	fprintf(cpp_file, "}\n");

	if(classes.creator!=NULL)
	{
		fprintf(cpp_file, "\n");
		fprintf(cpp_file, "int %s::Parser::find_some_creator_in_stack(int pos) const\n", data.variables.whale_namespace);
		fprintf(cpp_file, "{\n");
		if(data.variables.generate_verbose_prints)
		{
			fprintf(cpp_file, "\t#if WHALE_DEBUG != 0\n");
			fprintf(cpp_file, "\tif (m_debug)\n");
			fprintf(cpp_file, "\t{\n");
			fprintf(cpp_file, "\t\tcout << \x22" "find_some_creator_in_stack(): starting from \x22 << pos << \x22, \x22;\n");
			fprintf(cpp_file, "\t\tcout.flush();\n");
			fprintf(cpp_file, "\t}\n");
			fprintf(cpp_file, "\t#endif\n");
		}
		fprintf(cpp_file, "\tfor(int i=pos; i>=0; i--)\n");
		fprintf(cpp_file, "\t\tif(dynamic_cast<Creator *>(symbol_stack[i])!=NULL)\n");
		if(data.variables.generate_verbose_prints)
		{
			fprintf(cpp_file, "\t\t{\n");
			fprintf(cpp_file, "\t\t\t#if WHALE_DEBUG != 0\n");
			fprintf(cpp_file, "\t\t\tif (m_debug)\n");
			fprintf(cpp_file, "\t\t\t{\n");
			fprintf(cpp_file, "\t\t\t\tcout << \x22" "found at \x22 << i << \x22\\n\x22;\n");
			fprintf(cpp_file, "\t\t\t\treturn i;\n");
			fprintf(cpp_file, "\t\t\t}\n");
			fprintf(cpp_file, "\t\t\t#endif\n");
			fprintf(cpp_file, "\t\t}\n");
		}
		else
			fprintf(cpp_file, "\t\t\treturn i;\n");
		fprintf(cpp_file, "\t\n");
		if(data.variables.generate_verbose_prints) {
			fprintf(h_file, "\t#if WHALE_DEBUG != 0\n");
			fprintf(cpp_file, "\tif (m_debug)\n");
			fprintf(cpp_file, "\t\tcout << \x22" "found nothing.\\n\x22;\n");
			fprintf(h_file, "\t#endif\n");
		}
		fprintf(cpp_file, "\treturn -1;\n");
		fprintf(cpp_file, "}\n");
	}

	fprintf(cpp_file, "\n");
	fprintf(cpp_file, "void %s::Parser::print_stack(ostream &os) const\n", data.variables.whale_namespace);
	fprintf(cpp_file, "{\n");
	fprintf(cpp_file, "\tfor(unsigned i=0; i<state_stack.size(); i++)\n");
	fprintf(cpp_file, "\t{\n");
	fprintf(cpp_file, "\t\tos << \x22[\x22 << state_stack[i] << \x22]\x22;\n");
	fprintf(cpp_file, "\t\tif(i==symbol_stack.size()) break;\n");
	fprintf(cpp_file, "\t\tos << \x22 \x22 << typeid(*symbol_stack[i]).name() << \x22 \x22;\n");
	fprintf(cpp_file, "\t}\n");
	fprintf(cpp_file, "\tos << \x22\\n\x22;\n");
	fprintf(cpp_file, "}\n");

	fprintf(cpp_file, "\n");
	fprintf(cpp_file, "ostream &%s::print_terminal_location(ostream &os, const Terminal *t)\n", data.variables.whale_namespace);
	fprintf(cpp_file, "{\n");
	fprintf(cpp_file, "\treturn os << \x22line \x22 << t->line << \x22 column \x22 << t->column;\n");
	fprintf(cpp_file, "}\n");

	fprintf(cpp_file, "\n");
	generate_table_of_states(cpp_file);

	fprintf(cpp_file, "\n");
	generate_table_of_rules(cpp_file);

	if(data.variables.generate_table_of_pointers_to_members)
	{
		fprintf(cpp_file, "\n");
		generate_table_of_pointers_to_members(cpp_file);
	}

	fprintf(cpp_file, "\n");
	generate_raw_tables(cpp_file, "", true);

	if(data.variables.generate_visitor)
	{
		fprintf(cpp_file, "\nnamespace %s\n{\n", data.variables.whale_namespace);

		fprintf(cpp_file,
				"	void Visitor::traverse_children(const Nonterminal& t)\n"
				"	{\n"
				"		if(t.first_child)\n"
				"		{\n"
				"			for(Symbol *s=t.first_child; s; s=s->next_sibling)\n"
				"				s->accept(*this);\n"
				"		}\n"
				"	}\n\n");

		generate_visit_function(classes.terminal, cpp_file, "\t", 2);
		generate_visit_function(classes.nonterminal, cpp_file, "\t", 2);

		for(int i=0; i<data.nonterminals.size(); i++)
		{
			NonterminalData &nonterminal=data.nonterminals[i];

			if(!nonterminal.is_ancillary)
			{
				generate_visit_function(nonterminal.type, cpp_file, "\t", 2);

				for(int j=0; j<nonterminal.alternatives.size(); j++)
				{
					AlternativeData &alternative=nonterminal.alternatives[j];
					if(alternative.type)
						generate_visit_function(alternative.type, cpp_file, "\t", 2);
				}
			}
		}

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

	if(data.variables.xml_support)
		fprintf(cpp_file,
				"\nstd::string %s::xml_escape(const std::string &s)\n"
				"{\n"
				"	std::string result;\n"
				"	for (int i=0; i<s.size(); i++)\n"
				"		if (s[i]=='<')\n" 
				"			result+=\"&lt;\";\n"
				"		else if (s[i]=='>')\n"
				"			result+=\"&gt;\";\n"
				"		else if (s[i]=='&')\n"
				"			result+=\"&amp;\";\n"
				"		else if (s[i]=='\"')\n"
				"			result+=\"&quot;\";\n"
				"		else if (s[i]=='\\'')\n"
				"			result+=\"&apos;\";\n"
				"		else\n"
				"			result+=s[i];\n"
				"	return result;\n"
				"}\n", data.variables.whale_namespace);


	if(data.variables.code_in_cpp_after_all)
		fprintf(cpp_file, "\n%s\n", data.variables.code_in_cpp_after_all);

	fclose(cpp_file);
}

void generate_whale_class(FILE *a)
{
	fprintf(a, "\t\n"
		"\tclass Parser\n");
	fprintf(a, "\t{\n");
	fprintf(a, "\t\tstatic const char *whale_copyright_notice;\n");

	fprintf(a, "\t\t\n"
		"\tpublic:\n");

	generate_scalar_constants(a, "\t\t", false);

	fprintf(a, "\t\t\n");
	fprintf(a, "\tprotected:\n");
	fprintf(a, "\t\tclass LRAction\n");
	fprintf(a, "\t\t{\n");
	fprintf(a, "\t\t\tint n;\n");
	fprintf(a, "\t\t\t\n");
	fprintf(a, "\t\tpublic:\n");
	fprintf(a, "\t\t\tLRAction(int supplied_n=0) { n=supplied_n; }\n");
	fprintf(a, "\t\t\t\n");
	fprintf(a, "\t\t\tbool is_error() const { return !n; }\n");
	fprintf(a, "\t\t\tbool is_accept() const { return n==1; }\n");
	fprintf(a, "\t\t\tbool is_shift() const { return n<0; }\n");
	fprintf(a, "\t\t\tbool is_reduce() const { return n>=2; }\n");
	fprintf(a, "\t\t\tint shift_state() const { return -n-1; }\n");
	fprintf(a, "\t\t\tint reduce_rule() const { return n-1; }\n");
	fprintf(a, "\t\t\tint get_n() const { return n; }\n");
	fprintf(a, "\t\t\tstatic LRAction error() { return LRAction(0); }\n");
	fprintf(a, "\t\t\tstatic LRAction accept() { return LRAction(1); }\n");
	fprintf(a, "\t\t\tstatic LRAction shift(int state) { return LRAction(-state-1); }\n");
	fprintf(a, "\t\t\tstatic LRAction reduce(int rule) { return LRAction(rule+1); }\n");
	fprintf(a, "\t\t};\n");

	fprintf(a, "\t\tstruct StateData\n");
	fprintf(a, "\t\t{\n");

	if(!data.variables.compress_action_table)
		fprintf(a, "\t\t\tint action_table[number_of_terminals];\n");
	else if(data.variables.action_table_compression_mode<=2)
		fprintf(a, "\t\t\tint index_in_action_table;\n");
	else if(data.variables.action_table_compression_mode==3)
	{
		fprintf(a, "\t\t\tbool sole_action;\n");
		fprintf(a, "\t\t\tunion { int index_in_action_table, action_value; };\n");
	}
	else
		assert(false);

	if(data.variables.using_error_map)
		fprintf(a, "\t\t\tint index_in_action_error_map;\n");

	if(!data.variables.compress_goto_table)
		fprintf(a, "\t\t\tint goto_table[number_of_nonterminals];\n");
	else if(data.variables.goto_table_compression_mode<=2)
		fprintf(a, "\t\t\tint index_in_goto_table;\n");
	else if(data.variables.goto_table_compression_mode==3)
	{
		fprintf(a, "\t\t\tbool sole_goto;\n");
		fprintf(a, "\t\t\tunion { int index_in_goto_table, goto_value; };\n");
	}
	else
		assert(false);

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

	fprintf(a, "\t\tstruct RuleData\n");
	fprintf(a, "\t\t{\n");
	fprintf(a, "\t\t\tint nn;\n");
#ifdef MAKE_TABLE_OF_RULE_BODIES
	fprintf(a, "\t\t\tconst int *body;\n");
#endif
	fprintf(a, "\t\t\tint length;\n");
	fprintf(a, "\t\t};\n");
	fprintf(a, "\t\t\n");

	fprintf(a, "\t\tstatic const StateData states[number_of_lr_states];\n");
	fprintf(a, "\t\tstatic const RuleData rules[number_of_rules];\n");
	generate_raw_tables(a, "\t\t", false);

	fprintf(a, "\t\t\n");
	fprintf(a, "\tpublic:\n");
	fprintf(a, "\t\tParser(%s &lexical_analyzer_supplied) : lexical_analyzer(lexical_analyzer_supplied), m_debug(false)\n", data.variables.lexical_analyzer_class);
	fprintf(a, "\t\t{\n");
	if(data.variables.code_in_constructor)
		fprintf(a, "\t\t\t\n\t\t\t%s\n", data.variables.code_in_constructor);


	fprintf(a, "\t\t}\n");
	fprintf(a, "\t\tbool debug() const { return m_debug; }\n");
	fprintf(a, "\t\tvoid debug(bool b) { m_debug = b; }\n");
	fprintf(a, "\t\t~Parser();\n");
	fprintf(a, "\t\tvoid initialize();\n");
	const char *S_name=data.nonterminals[data.start_nonterminal_number].type->name.c_str();
	fprintf(a, "\t\t%s *parse();\n", S_name);
	fprintf(a, "\t\tvoid report_error(std::ostream &os, const Terminal *t) const;\n");
	fprintf(a, "\t\tbool recover_from_error();\n");
	if(classes.creator!=NULL)
		fprintf(a, "\t\tint find_some_creator_in_stack(int pos) const;\n");
	fprintf(a, "\t\tvoid print_stack(std::ostream &os) const;\n");

	fprintf(a, "\t\t\n");
	fprintf(a, "\tprotected:\n");
	fprintf(a, "\t\t%s &lexical_analyzer;\n", data.variables.lexical_analyzer_class);
	if(!data.variables.input_queue)
		fprintf(a, "\t\tTerminal *input_symbol;\n");
	else
		fprintf(a, "\t\tstd::queue<Terminal *> input_symbols;\n");
	fprintf(a, "\t\tstd::vector<int> state_stack;\n");
	fprintf(a, "\t\tstd::vector<Symbol *> symbol_stack;\n");
	fprintf(a, "\t\tstd::vector<Symbol *> garbage;\n");
	fprintf(a, "\t\tbool m_debug;\n");

	fprintf(a, "\t\t\n");
	fprintf(a, "\t\tLRAction access_action_table(int state, int tn) const\n");
	fprintf(a, "\t\t{\n");
	if(data.variables.using_error_map)
	{
		fprintf(a, "\t\t\tif(!access_error_map(compressed_action_error_map + states[state].index_in_action_error_map, tn))\n");
		fprintf(a, "\t\t\t\treturn LRAction::error();\n");
	}
	if(!data.variables.compress_action_table)
		fprintf(a, "\t\t\treturn LRAction(states[state].action_table[tn]);\n");
	else
	{
		if(data.variables.action_table_compression_mode==3)
		{
			fprintf(a, "\t\t\tif(states[state].sole_action)\n");
			fprintf(a, "\t\t\t\treturn states[state].action_value;\n");
		}

		fprintf(a, "\t\t\treturn LRAction(compressed_action_table[states[state].index_in_action_table+tn]);\n");
	}
	fprintf(a, "\t\t}\n");

	if(data.variables.using_error_map)
	{
		fprintf(a, "\t\tbool access_error_map(const unsigned int *map, int n) const\n");
		fprintf(a, "\t\t{\n");
		fprintf(a, "\t\t\treturn map[n/assumed_number_of_bits_in_int] & (1 << (n%%assumed_number_of_bits_in_int));\n");
		fprintf(a, "\t\t}\n");
	}

	fprintf(a, "\t\tint access_goto_table(int state, int nn) const\n");
	fprintf(a, "\t\t{\n");
	if(!data.variables.compress_action_table)
		fprintf(a, "\t\t\treturn states[state].goto_table[nn];\n");
	else
	{
		if(data.variables.goto_table_compression_mode==3)
		{
			fprintf(a, "\t\t\tif(states[state].sole_goto)\n");
			fprintf(a, "\t\t\t\treturn states[state].goto_value;\n");
		}

		fprintf(a, "\t\t\treturn compressed_goto_table[states[state].index_in_goto_table + nn];\n");
	}
	fprintf(a, "\t\t}\n");

	fprintf(a, "\t\tint find_nonterminal_in_stack(int nn) const\n");
	fprintf(a, "\t\t{\n");
	fprintf(a, "\t\t\tfor(int i=symbol_stack.size()-1; i>=0; i--)\n");
	fprintf(a, "\t\t\t\tif(symbol_stack[i]->is_nonterminal())\n");
	fprintf(a, "\t\t\t\t{\n");
	fprintf(a, "\t\t\t\t\tNonterminal *n=(Nonterminal *)symbol_stack[i];\n");
	fprintf(a, "\t\t\t\t\tif(n->number()==nn)\n");
	fprintf(a, "\t\t\t\t\t\treturn i;\n");
	fprintf(a, "\t\t\t\t}\n");
	fprintf(a, "\t\t\treturn -1;\n");
	fprintf(a, "\t\t}\n");

#if 0
	if(data.variables.make_creator_lookup_facility)
	{
		fprintf(a, "\t\tbool is_creator(int nn) const\n");
		fprintf(a, "\t\t{\n");
		fprintf(a, "\t\t\t// Ought to rewrite it using a table.\n");
		fprintf(a, "\t\t\t\n");

		fprintf(a, "\t\t\treturn ");
		vector<int> creators;
		for(int i=0; i<data.nonterminals.size(); i++)
			if(data.nonterminals[i].category==NonterminalData::CREATOR)
				creators.push_back(i);