process.cpp.svn-base

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

			// member has now with the type assigned to symbol.
			bool result=apply_common_ancestor_determination_procedure(m_expr->data_member_i->type, internal_class_for_this_symbol, expr_s.sn, m_expr->data_member_i, t);
			if(!result) return false;
			expr_s.data_member_i=m_expr->data_member_i;
		}
		else if(!m_expr->i_specified && m_expr->e_specified && !external_class_for_this_symbol)
		{
			bool result=apply_common_ancestor_determination_procedure(m_expr->data_member_e->internal_type_if_there_is_an_external_type, internal_class_for_this_symbol, expr_s.sn, m_expr->data_member_e, t);
			assert(result);
			expr_s.data_member_e=m_expr->data_member_e;
		}
		else if(m_expr->i_specified && m_expr->e_specified && !external_class_for_this_symbol)
		{
			bool result1=apply_common_ancestor_determination_procedure(m_expr->data_member_i->type, internal_class_for_this_symbol, expr_s.sn, m_expr->data_member_i, t);
			bool result2=apply_common_ancestor_determination_procedure(m_expr->data_member_e->internal_type_if_there_is_an_external_type, internal_class_for_this_symbol, expr_s.sn, m_expr->data_member_e, t);
			if(!result1 || !result2) return false;
			expr_s.data_member_i=m_expr->data_member_i;
			expr_s.data_member_e=m_expr->data_member_e;
		}
		else if(m_expr->i_specified && !m_expr->e_specified && external_class_for_this_symbol)
		{
			bool result1=apply_common_ancestor_determination_procedure(m_expr->data_member_i->type, external_class_for_this_symbol, expr_s.sn, m_expr->data_member_i, t);
			bool result2=apply_common_ancestor_determination_procedure(m_expr->data_member_i->internal_type_if_there_is_an_external_type, internal_class_for_this_symbol, expr_s.sn, m_expr->data_member_i, t);
			if(!result1 || !result2) return false;
			expr_s.data_member_e=m_expr->data_member_i;
		}
		else if(!m_expr->i_specified && m_expr->e_specified && external_class_for_this_symbol)
		{
			bool result1=apply_common_ancestor_determination_procedure(m_expr->data_member_e->type, external_class_for_this_symbol, expr_s.sn, m_expr->data_member_e, t);
			bool result2=apply_common_ancestor_determination_procedure(m_expr->data_member_e->internal_type_if_there_is_an_external_type, internal_class_for_this_symbol, expr_s.sn, m_expr->data_member_e, t);
			if(!result1 || !result2) return false;
			expr_s.data_member_e=m_expr->data_member_e;
		}
		else if(m_expr->i_specified && m_expr->e_specified && external_class_for_this_symbol)
		{
			bool result1=apply_common_ancestor_determination_procedure(m_expr->data_member_i->type, internal_class_for_this_symbol, expr_s.sn, m_expr->data_member_i, t);
			bool result2=apply_common_ancestor_determination_procedure(m_expr->data_member_e->type, external_class_for_this_symbol, expr_s.sn, m_expr->data_member_e, t);
			if(!result1 || !result2) return false;
			expr_s.data_member_i=m_expr->data_member_i;
			expr_s.data_member_e=m_expr->data_member_e;
		}
		else
			assert(false);

		return true;
	}
	else if(typeid(*expr)==typeid(NonterminalExpressionMemberName))
	{
		NonterminalExpressionMemberName &expr_mn=*dynamic_cast<NonterminalExpressionMemberName *>(expr);
		NonterminalMemberExpression *expr_m=expr_mn.expr_m;

		if(typeid(*expr_m)==typeid(NonterminalMemberExpressionNothing))
		{
			NonterminalMemberExpressionNothing &em_nothing=*dynamic_cast<NonterminalMemberExpressionNothing *>(expr_m);
			expr_m->is_nothing=true;
			expr_m->t=em_nothing.kw;
		}
		else if(typeid(*expr_m)==typeid(NonterminalMemberExpressionInternal))
		{
			NonterminalMemberExpressionInternal &em_internal=*dynamic_cast<NonterminalMemberExpressionInternal *>(expr_m);

			expr_m->scope_i=em_internal.scope;
			expr_m->name_i=em_internal.name;

			expr_m->i_specified=true;
			expr_m->t=em_internal.name;
		}
		else if(typeid(*expr_m)==typeid(NonterminalMemberExpressionExternal))
		{
			NonterminalMemberExpressionExternal &em_external=*dynamic_cast<NonterminalMemberExpressionExternal *>(expr_m);

			expr_m->type_e=em_external.type;
			expr_m->scope_e=em_external.scope;
			expr_m->name_e=em_external.name;

			expr_m->e_specified=true;
			expr_m->t=em_external.name;
		}
		else if(typeid(*expr_m)==typeid(NonterminalMemberExpressionBoth))
		{
			NonterminalMemberExpressionBoth &em_both=*dynamic_cast<NonterminalMemberExpressionBoth *>(expr_m);

			expr_m->scope_i=em_both.scope1;
			expr_m->name_i=em_both.name1;

			expr_m->type_e=em_both.type2;
			expr_m->scope_e=em_both.scope2;
			expr_m->name_e=em_both.name2;

			expr_m->i_specified=true;
			expr_m->e_specified=true;
			expr_m->t=em_both.name1;
		}
		else
			assert(false);

		bool local_flag=true;

		if(expr_m->i_specified)
		{
			expr_m->data_member_i=process_single_data_member_declaration(expr_m->scope_i, expr_m->name_i, proc_data.nn, proc_data.an, proc_data.number_of_nested_iterations);
			if(!expr_m->data_member_i)
				local_flag=false;
		}

		if(expr_m->e_specified)
		{
			expr_m->data_member_e=process_single_data_member_declaration(expr_m->scope_e, expr_m->name_e, proc_data.nn, proc_data.an, proc_data.number_of_nested_iterations);
			if(expr_m->data_member_e)
			{
				assert(expr_m->type_e);
				ClassHierarchy::Class *this_external_type=process_external_type_declaration(expr_m->type_e, NULL);
				if(expr_m->data_member_e->type &&
					expr_m->data_member_e->type!=this_external_type)
				{
					cout << "External class " << this_external_type->get_full_name()
						<< " cannot be assigned to data member "
						<< expr_m->name_e->text << " at ";
					expr_m->name_e->print_location(cout);
					cout << ", because the latter already has incompatible type ";
					cout << expr_m->data_member_e->type->get_full_name() << ".\n";
					local_flag=false;
				}
				else
					expr_m->data_member_e->type=this_external_type;

				if(!expr_m->data_member_e->type)
					local_flag=false;
			}
			else
				local_flag=false;
		}

		if(!local_flag)
			return false;

		NonterminalMemberExpression *backup=proc_data.member_expression;
		proc_data.member_expression=expr_mn.expr_m;

		bool result=process_expression_proc(expr_mn.expr, proc_data);

		proc_data.member_expression=backup;

		// in case no types were assigned to data members
		if(expr_m->i_specified)
		{
			assert(expr_m->data_member_i);

			if(!expr_m->data_member_i->type)
				expr_m->data_member_i->type=classes.symbol;
		}
		if(expr_m->e_specified)
		{
			assert(expr_m->data_member_e && expr_m->data_member_e->type);
		}

		if(!result) return false;

		if(!expr_mn.expr_m->number_of_affected_symbols)
		{
			cout << "Warning: member name declaration ";
			expr_mn.expr_m->t->print_location(cout);
			cout << " doesn't affect any symbols.\n";
		}

		return true;
	}
	else if(typeid(*expr)==typeid(NonterminalExpressionCreate))
	{
		NonterminalExpressionCreate &expr_create=*dynamic_cast<NonterminalExpressionCreate *>(expr);
		if(proc_data.nonterminal().category==NonterminalData::EXTERNAL)
		{
			cout << "Usage of create operator at ";
			expr_create.kw->print_location(cout);
			cout << " is illegal, because nonterminal "
				<< proc_data.nonterminal().name << ", ";
			proc_data.nonterminal().print_where_it_was_declared(cout);
			cout << ", is external.\n";
			return false;
		}
		else if(proc_data.inside_anything_but_concatenation)
		{
			cout << "Error at ";
			expr_create.kw->print_location(cout);
			cout << ": create operator can only appear on the top level of expression.\n";
			return false;
		}
		else if(proc_data.make_operator)
		{
			cout << "Create operator at ";
			proc_data.make_operator->kw->print_location(cout);
			cout << " cannot be invoked once more at ";
			expr_create.kw->print_location(cout);
			cout << ".\n";
			return false;
		}
		proc_data.make_operator=&expr_create;

		return true;
	}
	else if(typeid(*expr)==typeid(NonterminalExpressionUpdate))
	{
		NonterminalExpressionUpdate &expr_update=*dynamic_cast<NonterminalExpressionUpdate *>(expr);
		if(proc_data.inside_anything_but_concatenation)
		{
			cout << "Error at ";
			expr_update.kw->print_location(cout);
			cout << ": update operator can only appear on the top level of expression.\n";
			return false;
		}
		else if(!proc_data.make_operator)
		{
			cout << "Invalid use of update operator at ";
			expr_update.kw->print_location(cout);
			cout << ": a previous use of create operator is required.\n";
			return false;
		}
		return true;
	}
	else if(typeid(*expr)==typeid(NonterminalExpressionConnectUp))
	{
		NonterminalExpressionConnectUp &expr_up=*dynamic_cast<NonterminalExpressionConnectUp *>(expr);
		expr_up.used_after_make_operator=(proc_data.make_operator!=NULL);
		proc_data.nonterminal().requests_to_connect_up.push_back(&expr_up);
		data.variables.connect_up_operators_are_used=true;
		return true;
	}
	else if(typeid(*expr)==typeid(NonterminalExpressionCode))
		return true;
	else if(typeid(*expr)==typeid(NonterminalExpressionPrecedence))
		return true;
	else
	{
		assert(false);
		return false; // to p. the c.
	}
}

bool process_expression_proc_ii(NonterminalExpression *expr, ProcessExpressionProcIIData &proc_data)
{
	if(typeid(*expr)==typeid(NonterminalExpressionDisjunction))
	{
		NonterminalExpressionDisjunction &expr_d=*dynamic_cast<NonterminalExpressionDisjunction *>(expr);
		bool result1=process_expression_proc_ii(expr_d.expr1, proc_data);
		bool result2=process_expression_proc_ii(expr_d.expr2, proc_data);
		return result1 && result2;
	}
	else if(typeid(*expr)==typeid(NonterminalExpressionConjunction))
	{
		NonterminalExpressionConjunction &expr_c=*dynamic_cast<NonterminalExpressionConjunction *>(expr);
		bool result1=process_expression_proc_ii(expr_c.expr1, proc_data);
		bool result2=process_expression_proc_ii(expr_c.expr2, proc_data);
		return result1 && result2;
	}
	else if(typeid(*expr)==typeid(NonterminalExpressionConcatenation))
	{
		NonterminalExpressionConcatenation &expr_cat=*dynamic_cast<NonterminalExpressionConcatenation *>(expr);
		bool result1=process_expression_proc_ii(expr_cat.expr1, proc_data);
		bool result2=process_expression_proc_ii(expr_cat.expr2, proc_data);
		return result1 && result2;
	}
	else if(typeid(*expr)==typeid(NonterminalExpressionComplement))
	{
		NonterminalExpressionComplement &expr_com=*dynamic_cast<NonterminalExpressionComplement *>(expr);
		return process_expression_proc_ii(expr_com.expr, proc_data);
	}
	else if(typeid(*expr)==typeid(NonterminalExpressionOmittable))
	{
		NonterminalExpressionOmittable &expr_om=*dynamic_cast<NonterminalExpressionOmittable *>(expr);
		return process_expression_proc_ii(expr_om.expr, proc_data);
	}
	else if(typeid(*expr)==typeid(NonterminalExpressionInParentheses))
	{
		NonterminalExpressionInParentheses &expr_p=*dynamic_cast<NonterminalExpressionInParentheses *>(expr);
		return process_expression_proc_ii(expr_p.expr, proc_data);
	}
	else if(typeid(*expr)==typeid(NonterminalExpressionIteration))
	{
		NonterminalExpressionIteration &expr_it=*dynamic_cast<NonterminalExpressionIteration *>(expr);

		proc_data.bodies_in_our_way.push_back(expr_it.body_sn);
		bool result=process_expression_proc_ii(expr_it.expr, proc_data);
		proc_data.bodies_in_our_way.pop_back();

		return result;
	}
	else if(typeid(*expr)==typeid(NonterminalExpressionIterationPair))
	{
		NonterminalExpressionIterationPair &expr_it2=*dynamic_cast<NonterminalExpressionIterationPair *>(expr);

		proc_data.bodies_in_our_way.push_back(expr_it2.body1_sn);
		bool result1=process_expression_proc_ii(expr_it2.expr1, proc_data);
		proc_data.bodies_in_our_way.pop_back();

		proc_data.bodies_in_our_way.push_back(expr_it2.body2_sn);
		bool result2=process_expression_proc_ii(expr_it2.expr2, proc_data);
		proc_data.bodies_in_our_way.pop_back();

		return result1 && result2;
	}
	else if(typeid(*expr)==typeid(NonterminalExpressionEpsilon))
		return true;
	else if(typeid(*expr)==typeid(NonterminalExpressionSymbol))
	{
		NonterminalExpressionSymbol &expr_s=*dynamic_cast<NonterminalExpressionSymbol *>(expr);
		Terminal *t=expr_s.symbol;

		/* checking validity of connect_up operators */
		if(expr_s.sn.is_nonterminal())
		{
			int nn=expr_s.sn.nonterminal_number();
			NonterminalData &nonterminal=data.nonterminals[nn];

			if(nonterminal.requests_to_connect_up.size() && !proc_data.make_operator)
				proc_data.nonterminals_that_cannot_be_connected_up[nn].push_back(&expr_s);
		}

		/* making data members in iteration bodies */

		int iteration_depth=proc_data.bodies_in_our_way.size();

	#ifdef DEBUG_DATA_MEMBERS_IN_BODIES
		cout << "process_expression_proc_ii(), at ";
		t->print_location(cout);
		if(iteration_depth)
		{
			cout << ": ";
			for(int i=0; i<proc_data.bodies_in_our_way.size(); i++)
				cout << (i ? ", " : "")
					<< data.full_symbol_name(proc_data.bodies_in_our_way[i], !i);
			cout << ".\n";
		}
		else
			cout << ".\n";
	#endif

		ClassHierarchy::DataMember *prototype_data_member;
		ClassHierarchy::Class *type_we_shall_use;
		string name_we_shall_use;
		if(expr_s.data_member_i)
		{
			prototype_data_member=expr_s.data_member_i;
			if(expr_s.data_member_i->internal_type_if_there_is_an_external_type)
				type_we_shall_use=expr_s.data_member_i->internal_type_if_there_is_an_external_type;
			else
				type_we_shall_use=expr_s.data_member_i->type;
			name_we_shall_use=expr_s.data_member_i->name;
		}
		else if(expr_s.data_member_e)
		{
			assert(expr_s.data_member_e->internal_type_if_there_is_an_external_type);
			prototype_data_member=expr_s.data_member_e;
			type_we_shall_use=expr_s.data_member_e->internal_type_if_there_is_an_external_type;
			name_we_shall_use=expr_s.data_member_e->name;
		}
		else
		{
			// it is 'nothing'.
			return true;
		}

		bool flag=true;
		for(int i=0; i<iteration_depth; i++)
		{
			SymbolNumber sn=proc_data.bodies_in_our_way[i];

		#ifdef DEBUG_DATA_MEMBERS_IN_BODIES
			cout << "\t" << data.full_symbol_name(sn, true) << ": ";
		#endif
			if(sn.is_nonterminal() && data.nonterminals[sn.nonterminal_number()].is_ancillary)
			{
				NonterminalData &nonterminal=data.nonterminals[sn.nonterminal_number()];
				assert(nonterminal.category==NonterminalData::BODY);

				if(proc_data.data_members_already_processed.count(make_pair(prototype_data_member, sn.nonterminal_number())))
				{
					bool flag=false;
					std::vector<ClassHierarchy::DataMember *> &v=proc_data.data_members_already_processed[make_pair(prototype_data_member, sn.nonterminal_number())]->data_members_in_bodies;
					for(int j=0; j<v.size(); j++)
						if(v[j]->belongs_to==nonterminal.type)
						{
						#ifdef DEBUG_DATA_MEMBERS_IN_BODIES
							cout << "reusing " << v[j]->get_full_name() << ".\n";
						#endif
							assert(!flag);
							expr_s.data_members_in_bodies.push_back(v[j]);
							flag=true;
						}
					assert(flag);
				}
				else