variables.cpp.svn-base

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

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

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

    if(data.variables.xml_support)
        data.variables.generate_names = true;

	if(data.variables.method==Variables::LR1 && data.variables.dump_canonical_conflicts)
		cerr << "warning: dump_canonical_conflicts not implemented in LR1 mode.\n";

	return flag;
}

bool assign_values_to_variables_stage_two()
{
	if(data.assignments.count("code_in_class"))
	{
		vector<AssignmentData> &v_ad=data.assignments["code_in_class"];
		for(int i=0; i<v_ad.size(); i++)
		{
			AssignmentData &ad=v_ad[i];
			assert(ad.values.size()==1);
			assert(ad.parameters.size()<=1);

			if(ad.parameters.size()==1)
			{
				assert(ad.declaration->middle.size()==1);

				ClassHierarchy::Class *target_class=classes.find(ad.parameters[0].first);
				if(target_class==NULL)
				{
					cout << "Unknown class " << ad.parameters[0].first << " at ";
					ad.declaration->middle[0]->print_location(cout);
					cout << ".\n";
					continue;
				}
				else if(!target_class->is_internal)
				{
					cout << "Class " << target_class->name << ", ";
					target_class->print_where_it_was_declared(cout);
					cout << " is an external class and, therefore, assignment at ";
				//	cout << ad.parameters[0].first << " at ";
					ad.declaration->middle[0]->print_location(cout);
					cout << " is invalid.\n";
					continue;
				}
				assert(target_class->code==NULL);
				target_class->code=ad.values[0].first;
			}
			else
				data.variables.code_in_parser_class=ad.values[0].first;
		}
	}

	return true;
}

void report_wrong_parameters(ostream &os, const char *variable, NonterminalOptionStatement *st, const char *additional_text)
{
	os << "Wrong value assigned to variable '" << variable << "'";
	if(st)
	{
		cout << " at ";
		st->left->print_location(os);
	}
	else
		cout << " in command line";

	if(additional_text)
		os << ", " << additional_text;
	os << ".\n";
}

void report_ignored_parameters(ostream &os, const char *variable, NonterminalOptionStatement *st, const char *additional_text)
{
	os << "Warning: assignment to '" << variable << "' ignored";
	if(st)
	{
		cout << " at ";
		st->left->print_location(os);
	}
	else
		cout << " in command line";

	if(additional_text)
		os << ", " << additional_text;
	os << ".\n";
}

bool assign_value_to_id_or_string_variable(char *&variable, char *variable_name)
{
	if(!data.assignments.count(variable_name))
	{
		variable=NULL;
		return true;
	}
	assert(data.assignments[variable_name].size()==1);
	AssignmentData &ad=data.assignments[variable_name][0];
	int n=ad.values.size();

	if(n==1 && (ad.values[0].second==AssignmentData::VALUE_ID || ad.values[0].second==AssignmentData::VALUE_STRING))
	{
		variable=ad.values[0].first;
		return true;
	}
	else
	{
		report_wrong_parameters(cout, variable_name, ad.declaration,
			"expecting either an identifier or a string");
		return false;
	}
}

// returns true if no error is found, false otherwise.
// *** The return value has nothing to do with the value of the variable! ***
bool assign_value_to_bool_variable(bool &variable, char *variable_name, bool default_value)
{
	if(!data.assignments.count(variable_name))
	{
		variable=default_value;
		return true;
	}
	assert(data.assignments[variable_name].size()==1);
	AssignmentData &ad=data.assignments[variable_name][0];
	int n=ad.values.size();

	if(n==1 && ad.values[0].second==AssignmentData::VALUE_TRUE)
	{
		variable=true;
		return true;
	}
	else if(n==1 && ad.values[0].second==AssignmentData::VALUE_FALSE)
	{
		variable=false;
		return true;
	}
	else
	{
		report_wrong_parameters(cout, variable_name, ad.declaration,
			"expecting either 'true' or 'false'");
		return false;
	}
}

bool assign_value_to_code_variable(char *&variable, char *variable_name)
{
	if(!data.assignments.count(variable_name))
	{
		variable=NULL;
		return true;
	}
	assert(data.assignments[variable_name].size()==1);
	AssignmentData &ad=data.assignments[variable_name][0];
	int n=ad.values.size();

	if(n==1 && (ad.values[0].second==AssignmentData::VALUE_STRING || ad.values[0].second==AssignmentData::VALUE_CODE ))
	{
		variable=ad.values[0].first;
		return true;
	}
	else
	{
		report_wrong_parameters(cout, variable_name, ad.declaration,
			"expecting C++ code");
		return false;
	}
}

struct CharWithDollar
{
	char c;
	CharWithDollar(char c1) { c=c1; }
	operator char() const { return c; }
};

ostream &operator <<(ostream &os, CharWithDollar cwd)
{
	return os << '$' << char(cwd);
}

bool process_parametrized_string(char *&variable, char *variable_name, char *parameters)
{
	if(!data.assignments.count(variable_name))
		return true;
	assert(data.assignments[variable_name].size()==1);
	AssignmentData &ad=data.assignments[variable_name][0];
	int n=ad.values.size();

	if(n==1 && ad.values[0].second==AssignmentData::VALUE_STRING)
	{
		int np=strlen(parameters);
		char *s=ad.values[0].first;

		set<CharWithDollar> unused_parameters, invalid_parameters;
		for(int j=0; j<np; j++)
			unused_parameters.insert(CharWithDollar(parameters[j]));

		bool after_dollar=false;
		for(int i=0; s[i]; i++)
		{
			char c=s[i];
			if(after_dollar)
			{
				if(c!='$' && c>' ' && c<128)
				{
					bool local_flag=false;
					for(int j=0; j<np; j++)
						if(parameters[j]==c)
						{
							unused_parameters.erase(CharWithDollar(c));
							local_flag=true;
							break;
						}
					if(!local_flag)
						invalid_parameters.insert(CharWithDollar(c));
				}
				after_dollar=false;
			}
			else if(c=='$')
				after_dollar=true;
		}

		assert(ad.declaration);
		if(unused_parameters.size())
		{
			cout << "Warning: unused parameter" << (unused_parameters.size()==1 ? " " : "s ");
			print_with_and(cout, unused_parameters.begin(), unused_parameters.end());
			cout << " in string at ";
			ad.declaration->right[0]->print_location(cout);
			cout << ".\n";
		}
		if(invalid_parameters.size())
		{
			cout << "Invalid parameter" << (invalid_parameters.size()==1 ? " " : "s ");
			print_with_and(cout, invalid_parameters.begin(), invalid_parameters.end());
			cout << " in string at ";
			ad.declaration->right[0]->print_location(cout);
			cout << ".\n";
			return false;
		}

		variable=s;
	}
	else
	{
		report_wrong_parameters(cout, variable_name, ad.declaration,
			"expecting a string");
		return false;
	}

	return true;
}