编译原理实验代码

编译原理实验代码（有Bug）

/*
#include "pch.h"
#include "exe2.h"
#include<memory>
int main()
{
	//终结符
	list<string> terminator;

	terminator.push_back("a");
	terminator.push_back("b");
	terminator.push_back("c");
	terminator.push_back("d");
	terminator.push_back("(");
	terminator.push_back(")");
	terminator.push_back("+");
	terminator.push_back("-");
	terminator.push_back("*");
	terminator.push_back("/");

	list<string> not_terminator;
	not_terminator.push_back("E");
	not_terminator.push_back("T");
	not_terminator.push_back("F");
	not_terminator.push_back("W0");
	not_terminator.push_back("W1");
	not_terminator.push_back("I");
	exe2 wkn(not_terminator,terminator);

	//((a+b)*c/d+b*(a-c))*a
	wkn.add_expression("(");
	wkn.add_expression("(");
	wkn.add_expression("a");
	wkn.add_expression("+");
	wkn.add_expression("b");
	wkn.add_expression(")");
	wkn.add_expression("*");
	wkn.add_expression("c");
	wkn.add_expression("/");
	wkn.add_expression("d");
	wkn.add_expression("+");
	wkn.add_expression("b");
	wkn.add_expression("*");
	wkn.add_expression("(");
	wkn.add_expression("a");
	wkn.add_expression("-");
	wkn.add_expression("c");
	wkn.add_expression(")");
	wkn.add_expression(")");
	wkn.add_expression("*");
	wkn.add_expression("a");
	wkn.add_expression("#");

	list<list<string>> R;
	list<string> exp;
	exp.push_back("T");
	R.push_back(exp);
	exp.clear();
	exp.push_back("E");
	exp.push_back("W0");
	exp.push_back("T");
	R.push_back(exp);
	wkn.add_struct_grammer("E",R);

	R.clear();
	exp.clear();
	exp.push_back("F");
	R.push_back(exp);
	exp.clear();
	exp.push_back("T");
	exp.push_back("W1");
	exp.push_back("F");
	R.push_back(exp);
	wkn.add_struct_grammer("T", R);

	R.clear();
	exp.clear();
	exp.push_back("+");
	R.push_back(exp);
	exp.clear();
	exp.push_back("-");
	R.push_back(exp);
	wkn.add_struct_grammer("W0", R);

	R.clear();
	exp.clear();
	exp.push_back("*");
	R.push_back(exp);
	exp.clear();
	exp.push_back("/");
	R.push_back(exp);
	wkn.add_struct_grammer("W1", R);

	R.clear();
	exp.clear();
	exp.push_back("I");
	R.push_back(exp);
	exp.clear();
	exp.push_back("(");
	exp.push_back("E");
	exp.push_back(")");
	R.push_back(exp);
	wkn.add_struct_grammer("F", R);

	R.clear();
	exp.clear();
	exp.push_back("a");
	R.push_back(exp);
	exp.clear();
	exp.push_back("b");
	R.push_back(exp);
	exp.clear();
	exp.push_back("c");
	R.push_back(exp);
	exp.clear();
	exp.push_back("d");
	R.push_back(exp);
	wkn.add_struct_grammer("I", R);



	try {
		wkn.done_LL1("E");
	}
	catch(string r)
	{
		cout << r<<endl;
	}
	//wkn.find_first("A");


	return 0;
}
*/

#include "pch.h"
//#include "exe2.h"
#include <iostream>
#include <vector>
#include <iostream>
#include <fstream>
#include <cassert>
#include <string>
#include <list>
#include <iomanip>
#include <sstream>
#include<memory>
using namespace std;

string string_keyword[] = { "int","main","if","return","char","else" };
int string_keyword_len = 5;
string string_operator[] = { "(",")","\"","\'","+","-","*",",",";","\." ,"=", "/", "{","}","<",">",">=", "<=","&&","||" };
int string_operator_len = 20;
struct A
{
	string name;
	int id;
};
struct B
{
	char kind;
	int id;
};
class word_kind
{
private:

	ifstream infile;
	int class_i = 0, class_C = 0, class_s = 0, class_c = 0, class_k = 0, class_p = 0;
public:

	list<struct A> token_i, token_C, token_s, token_c, token_k, token_p;
	list<struct B> out_put;
	list<string> List_get_word;
	string reverse(char name, int id);	//用来逆向解析
	void read(string file);
	word_kind(string s);
	void fengli();
};

string word_kind::reverse(char name, int id)
{
	list<struct A>::iterator s_i;
	id--;
	if (name == 'i')
	{
		s_i = token_i.begin();
		for (int i = 0; i < id; i++)
			s_i++;

		return (*s_i).name;
	}
	if (name == 'C')
	{
		s_i = token_C.begin();
		for (int i = 0; i < id; i++)
			s_i++;
		return (*s_i).name;
	}
	if (name == 's')
	{
		s_i = token_s.begin();
		for (int i = 0; i < id; i++)
			s_i++;
		return (*s_i).name;
	}
	if (name == 'c')
	{
		s_i = token_c.begin();
		for (int i = 0; i < id; i++)
			s_i++;
		return (*s_i).name;
	}
	if (name == 'k')
	{
		s_i = token_k.begin();
		for (int i = 0; i < id; i++)
			s_i++;
		return (*s_i).name;
	}
	if (name == 'p')
	{
		
		s_i = token_p.begin();
		for (int i = 0; i < id; i++)
		{
			
			s_i++;
		}
		
		return (*s_i).name;
	}
}
void word_kind::fengli()
{
	bool flag_opt = true;
	while (!List_get_word.empty())
	{

		string tmp = List_get_word.front();

		List_get_word.pop_front();
		char tmp_c = tmp[0];

		if (tmp_c == '\"')//是个字符串
		{
			flag_opt = false;
			struct A strct_s;
			strct_s.name = tmp;
			strct_s.id = ++class_s;
			token_s.push_back(strct_s);

			struct B struct_out_put;
			struct_out_put.kind = 's';
			struct_out_put.id = class_s;
			out_put.push_back(struct_out_put);
			continue;
		}


		if (tmp_c == '\'')//是个字符
		{
			flag_opt = false;
			struct A strct_s;
			strct_s.name = tmp;
			strct_s.id = ++class_C;
			token_C.push_back(strct_s);

			struct B struct_out_put;
			struct_out_put.kind = 'C';
			struct_out_put.id = class_C;
			out_put.push_back(struct_out_put);
			continue;
		}

		if (tmp_c >= '0' && tmp_c <= '9')//是个常数
		{
			for (int j = 0; j < tmp.length(); j++)
			{
				if (!(tmp[j] >= '0'&&tmp[j] <= '9'))//不是纯数字
				{
					cout << "error  not a number" << endl;
					continue;
				}
			}
			flag_opt = false;
			struct A strct_s;
			strct_s.name = tmp;
			strct_s.id = ++class_c;
			token_c.push_back(strct_s);

			struct B struct_out_put;
			struct_out_put.kind = 'c';
			struct_out_put.id = class_c;
			out_put.push_back(struct_out_put);
			continue;
		}
		if (tmp_c >= 'a' && tmp_c <= 'z' || tmp_c >= 'A' && tmp_c <= 'Z' || tmp_c == '_')//是个标识符 或者 关键字
		{
			bool flag = true;
			for (int i = 0; i < string_keyword_len; i++)//判断是否为关键字
			{

				if (!tmp.compare(string_keyword[i]))//匹配中关键字了
				{
					//判断是否有重复标识符
					flag_opt = false;
					flag = false;
					struct A strct_s;
					strct_s.name = tmp;
					strct_s.id = ++class_k;
					token_k.push_back(strct_s);

					struct B struct_out_put;
					struct_out_put.kind = 'k';
					struct_out_put.id = class_k;
					out_put.push_back(struct_out_put);

				}

			}
			if (flag)//没有匹配中关键字  就是个标识符了
			{
				flag_opt = false;
				struct A strct_s;
				strct_s.name = tmp;
				strct_s.id = ++class_i;
				token_i.push_back(strct_s);

				struct B struct_out_put;
				struct_out_put.kind = 'i';
				struct_out_put.id = class_i;
				out_put.push_back(struct_out_put);
			}
			continue;
		}

		for (int i = 0; i < string_operator_len; i++)
		{
			if (!(tmp.compare(string_operator[i])))
			{
				//cout << "当前的字符串是" << tmp << "++++++++++++++++   " << string_operator[0] << endl;
				flag_opt = false;
				struct A strct_s;
				strct_s.name = tmp;
				strct_s.id = ++class_p;
				token_p.push_back(strct_s);
				//cout << "p     界符确认完成 是" << tmp << " 第" << class_p<< endl;
				struct B struct_out_put;
				struct_out_put.kind = 'p';
				struct_out_put.id = class_p;
				out_put.push_back(struct_out_put);

			}
		}
		if (flag_opt)
		{
			cout << "无法识别的字符串" << tmp << endl;
		}
	}
	//if(token_i)
}

void word_kind::read(string file)		//生成一个不含空格的List的总数据组
{
	string word = "";
	char c;
	List_get_word.clear();

	infile.open(file.data());
	string string_opt;
	string_opt.clear();

	list<char> list_word_all;
	infile >> noskipws;
	while (!infile.eof())
	{
		infile >> c;
		list_word_all.push_back(c);
	}
	list_word_all.pop_back();
	infile.close();

	list_word_all.push_front('(');
	list_word_all.push_back(')');

	while (!list_word_all.empty())
	{

		c = list_word_all.front();
		list_word_all.pop_front();
		if (c == ' ' || c == '\n')	//跳过空格
		{
			if (word != "")		//只要不为空  标识符和操作符都入栈
			{
				List_get_word.push_back(word);
				word.clear();
			}
			if (string_opt != "")
			{
				List_get_word.push_back(string_opt);
				string_opt.clear();
			}
			continue;
		}


		if ((c >= 'a'&&c <= 'z' || c >= 'A'&&c <= 'Z' || c == '_' || c >= '0'&&c <= '9'))	//常规字符
		{
			if (string_opt != "")
			{
				List_get_word.push_back(string_opt);//操作符入栈
				string_opt.clear();
			}
			word += c;
		}
		else   //是界定符号
		{
			if (word != "")
			{
				List_get_word.push_back(word);
				word.clear();
			}

			bool flag = true;
			for (int i = 0; i < string_operator_len - 6; i++)	//单目界符
			{

				if (c == string_operator[i][0])
				{
					string string_const;

					if (c == '\"')			//如果是 双引号和单引号  就要生成字符串和字符
					{
						string_const = c;	//加入“
						char tmp_c = c;
						list_word_all.pop_front();
						while (1)
						{
							tmp_c = c;
							c = list_word_all.front();
							list_word_all.pop_front();
							string_const += c;
							if (c == '\"')
							{
								if (tmp_c != '\\')
									break;
							}
						}
					}
					if (string_const != "")
					{
						List_get_word.push_back(string_const);
						string_const.clear();
						break;
					}

					if (c == '\'')//如果是 双引号和单引号  就要生成字符串和字符
					{

						string_const = c;		//第一个单引号写入
						c = list_word_all.front();
						list_word_all.pop_front();
						if (c == '\\')		//'\T'xingshi
						{
							string_const += c;		//  /写入
							c = list_word_all.front();
							list_word_all.pop_front();
							string_const += c;		//字母写入
							c = list_word_all.front();
							list_word_all.pop_front();

							if (c == '\'')
							{

								string_const += c;		//像匹配的单引号写入
								c = list_word_all.front();
								list_word_all.pop_front();
							}
							else
								cout << "error  识别常量字符时" << endl;
						}
						else    //'a' 形式
						{
							string_const += c;	//第一个字母写入
							c = list_word_all.front();
							list_word_all.pop_front();
							if (c == '\'')
							{
								string_const += c;		//第二个单引号写入
							}
							else
								cout << "error '" << endl;
						}
					}
					if (string_const != "")
					{
						List_get_word.push_back(string_const);
						string_const.clear();
						break;
					}

					if (word != "")			//不为空就将字符的入list
					{
						List_get_word.push_back(word);
						word.clear();
					}
					string_opt = c;
					List_get_word.push_back(string_opt);
					string_opt.clear();
					flag = false;
				}
			}
			bool flag_f = true;
			if (flag)
				for (int i = string_operator_len - 6; i < string_operator_len; i++)//双目界定符
				{
					if (c == string_operator[i][0])		//第一个界符匹配上
					{
						if (word != "")			//不为空就将字符的入list
						{
							List_get_word.push_back(word);
							word.clear();
						}
						char tmp_;
						tmp_ = c;

						c = list_word_all.front();
						list_word_all.pop_front();

						if (c == ' ' || c == '_' || c >= 'a'&&c <= 'z' || c >= 'A'&&c <= 'Z' || c >= '0'&&c <= '9')//如果c是空格或这字符串 标识符等  识别到此结束
						{
							flag_f = false;
							string_opt = tmp_;
							List_get_word.push_back(string_opt);
							string_opt.clear();
							list_word_all.push_front(c);
						}
						else {
							bool flag_tow = true;
							string tmp_tow_op;
							tmp_tow_op = tmp_;
							tmp_tow_op += c;
							for (int j = string_operator_len - 6; j < string_operator_len; j++)
								if (tmp_tow_op._Equal(string_operator[j]))
								{
									flag_f = false;
									flag_tow = false;
									List_get_word.push_back(tmp_tow_op);
									tmp_tow_op.clear();
									goto goto_end_two_op;
								}
							if (flag_tow)
								cout << "识别二目 界定符 在第二个符号上出错:" << tmp_tow_op << endl;
						}
					}
				}
		goto_end_two_op:
			if (flag_f&& flag)
				cout << "判断一元界符出错" << c << endl;
			int x = 0;
		}//界定符匹配结束
	}
	//List_get_word.pop_back();
	
}

word_kind::word_kind(string s)//从总List中选择数据，一个一个匹配
{
	read(s);
	fengli();
	out_put.pop_back();
	out_put.pop_front();
}






int string_Q_len;

string string_Q[] = { "T","E","F" ,"E" ,"E" ,"E" ,"E" ,"E" };	//非终结符
string string_q[] = { "","" };	//终结符




//test_left_change（）中给出了如何添加一个文法的方法
void show_list_string(list<string> R)
{
	cout << endl;
	list<string>::iterator i = R.begin();
	for (; i != R.end(); i++)
		cout << (*i) << "  ";
	cout << endl;
}

struct struct_QT
{
	string op, source1, source2, res;
}typedef strcut_QT;

struct struct_exe2		//一个非终结符对应的所有文法句子 example： 一条  T -> T+F |T-F 
{
	int number;			//该条文法规则编号
	string start_un;	//规则集的推导左边符号
	list<list<string>> SYN;	//规则集的推导右边式子 二维list了
}typedef struct_exe;

struct state_sentence_index
{
	int sentence;
	int index;
}typedef state_sentence_index;

struct tmp_table_foresee	//生成table的中间结构体 
{
	string not_terminator;	//表达式左部非终结符
	int number;				//表达式的编号 
	list<string> content;	//该表达式的期望遇见符号
}typedef tmp_table_foresee;

string trans_number_to_string(int num)	//将数字转化为字符串
{
	string res;
	stringstream ss;
	ss << num;
	ss >> res;
	return res;
}

void show_list_QT(list<struct_QT> r)
{
	list<struct_QT>::iterator list_string_i = r.begin();
	for (; list_string_i != r.end(); list_string_i++)
	{
		cout << "(" << (*list_string_i).op << "," << (*list_string_i).source1 << "," << (*list_string_i).source2 << "," << (*list_string_i).res << ")" << endl;
	}
}

class exe2
{
private:
	string SEM_tmp;	//用于生成一个在SEM中使用的临时变量
	int SEM_tmp_int;	//和上一行变量合起来生成一个临时变量


	int size_empty;
	int sentence_number;		//当前文法句子的编号
	string start_not_terminatroe;			//开始 非终结符
	int cur_state;							//当前状态     标志在当前推导式中 处理到了什么地方
	list<struct_exe> list_all_grammer;		//所有文法规则的链表
	list<state_sentence_index> list_stack_state;		//当前状态栈 在子程序调用时保护现场 在子程序返回时恢复现场

	string cur_w;							//当前正在处理的字符
	list<string> now_find_first_left;

	list<string> list_can_empty;	//能够推出空的非终结符
	list<string> list_SYN;				//SYN栈  递归子程序栈
	list<string> list_stack_grammar;		//文法翻译
	list<string> list_stack_SEM;			//SEM栈   暂不启用
	list<struct_QT> list_stack_QT;			//QT栈  生成的四元式列表
	list<string> list_string_terminator;	//终结符链表
	list<string> list_string_not_terminator;//非终结符链表
	list<string> wait_trans_expression;		//待翻译的表达式
	list<tmp_table_foresee> list_tmp_table_foresee;		//预见表

public:
	list<string> list_equal_i;
	exe2(list<string> VN, list<string> VT);	//传入非终结符链表 传入终结符链表

	bool if_is_not_terminator(string x);	//是否是一个非终结符
	bool if_is_terminator(string x);		//是否是一个终结符

	void add_struct_grammer(string fun_stat_un, list<list<string>> x);//添加一条语法
	void add_expression(string string_express);//添加待翻译表达式
	void test_show_after_left_change();//显示所有文法
	void show_foresee_table();		//显示遇见表

	void print();	//打印出当前SYN和当前序列 剩余序列


	void change_left_grammer();				//左递归文法变化
	void test_left_change();	//用来测试一个左递归转换

	string get_w();		//获取一个字符串

	void find_empty();
	void show_empty_list();
	bool not_terminator_if_is_empty(string x);	//判断一个非终结符是否能否推出空推导
	void find_can_empty_not_terminator();	//返回可以推导出空的非终结符
	list<string> find_first(string Left, string A);//返回字符a的首字符
	list<string> find_follow(string a);//返回字符a的后继符
	void generate_table();	//生成预见表
	list<string> get_grammer(string left_not_terminator);//根据形参给出的左部非终结符 和 当前字符cur_w 返回某一条表达式
	void done_LL1(string start_not_terminator);
	void done_one_opter(string opteration);
	void done_two_opter(string opteration);
	void add_express_from_file();
	string read_txt(string filename);
	bool if_is_equal_i(string x);
	



	void fun_start();	//开始函数
	void fun_E();		//子程序E
	void fun_E1();		//子程序E1
	void fun_T();		//子程序T
	void fun_T1();		//子程序T1
	void fun_F();		//子程序F
	void start_done();	//递归子程序翻译法
	void test_digui();	//递归下降法测试

	bool sort_struct_exe2_start_un(const struct_exe & m1, const struct_exe& m2);
};
string exe2::read_txt(string filename)
{
	ifstream infile;
	infile.open(filename.data());   //将文件流对象与文件连接起来 
	assert(infile.is_open());   //若失败,则输出错误消息,并终止程序运行 
	string s;
	while (getline(infile, s))
	{
		cout << s << endl;
	}
	infile.close();             //关闭文件输入流 
	return s;
}

bool exe2::if_is_equal_i(string x)
{
	list<string>::iterator list_i;
	for (list_i = list_equal_i.begin(); list_i != list_equal_i.end(); list_i++)
		if ((*list_i) == x)
			return true;
	return false;
}

void exe2::add_express_from_file()
{
	string content;
	content = read_txt("D:\\编译原理\\编译原理\\");
	string::iterator string_i = content.begin();
	while (string_i != content.end())
	{
		if ((*string_i) == ' ')
			content.erase(string_i);


		string_i++;
	}
}

void exe2::done_two_opter(string opteration)	//生成一个双目运算 四元式
{
	cout << "done_two_opter()  " << opteration << endl;
	struct_QT tmp_struct;
	tmp_struct.op = opteration;
	tmp_struct.source2 = list_stack_SEM.back();
	list_stack_SEM.pop_back();
	tmp_struct.source1 = list_stack_SEM.back();
	list_stack_SEM.pop_back();
	SEM_tmp_int++;
	tmp_struct.res = SEM_tmp + trans_number_to_string(SEM_tmp_int);
	list_stack_SEM.push_back(SEM_tmp + trans_number_to_string(SEM_tmp_int));
	list_stack_QT.push_back(tmp_struct);
}

void exe2::done_one_opter(string opteration)	//生成一个单目运算 四元式 
{
	struct_QT tmp_struct;
	tmp_struct.op = opteration;
	tmp_struct.source1 = list_stack_SEM.back();
	list_stack_SEM.pop_back();
	tmp_struct.source2 = "";
	SEM_tmp_int++;
	tmp_struct.res = SEM_tmp + trans_number_to_string(SEM_tmp_int);//生成一个临时变量
	list_stack_SEM.push_back(SEM_tmp + trans_number_to_string(SEM_tmp_int));
	list_stack_QT.push_back(tmp_struct);
}

exe2::exe2(list<string> F_VN, list<string> F_VT)
{		   //传入非终结符链表    传入终结符链表
	list_string_not_terminator = F_VN;
	list_string_terminator = F_VT;
	sentence_number = 0;
	list_tmp_table_foresee.clear();
	SEM_tmp = "t";//临时变量的前缀 t1  t2  t3
}

bool exe2::not_terminator_if_is_empty(string x)
{
	list<string>::iterator tmp_iter;
	for (tmp_iter = list_can_empty.begin(); tmp_iter != list_can_empty.end(); tmp_iter++)
	{
		if ((*tmp_iter) == x)
			return true;
	}
	return false;
}

void exe2::show_empty_list()
{
	list<string>::iterator  x;
	cout << "show_empty_list()  显示可推出空的非终结符为" << endl;
	for (x = list_can_empty.begin(); x != list_can_empty.end(); x++)
	{
		cout << (*x) << "  ";
	}
	cout << endl;
}

void exe2::find_can_empty_not_terminator()	//返回可以推导出空的非终结符
{
	//初始化 找出可以推导空的非终结符
	list_can_empty.clear();
	list<struct_exe>::iterator list_stru_iter;
	for (list_stru_iter = list_all_grammer.begin(); list_stru_iter != list_all_grammer.end(); list_stru_iter++)
	{
		list<list<string>>::iterator iter_express;
		for (iter_express = (*list_stru_iter).SYN.begin(); iter_express != (*list_stru_iter).SYN.end(); iter_express++)
		{
			if ((*iter_express).front() == "$")
			{//推导出了空  将其左部加入链表中
				list_can_empty.push_back((*list_stru_iter).start_un);
			}
		}
	}
	list_can_empty.unique();
	//初始化结束
	int tmp_size_empty = 0;
	size_empty = list_can_empty.size();
	while (tmp_size_empty != size_empty)
	{
		tmp_size_empty = size_empty;
		find_empty();
		size_empty = list_can_empty.size();
	}

}

void exe2::find_empty()
{
	list<struct_exe>::iterator iter_list_struct;
	bool flag;
	for (iter_list_struct = list_all_grammer.begin(); iter_list_struct != list_all_grammer.end(); iter_list_struct++)
	{

		if (not_terminator_if_is_empty((*iter_list_struct).start_un))
			continue;		//该非终结符已经可以推出空 不需要再遍历
		list<list<string>>::iterator iter_list_list_string;
		for (iter_list_list_string = (*iter_list_struct).SYN.begin(); iter_list_list_string != (*iter_list_struct).SYN.end(); iter_list_list_string++)
		{
			flag = true;
			list<string>::iterator iter_list_string;
			for (iter_list_string = (*iter_list_list_string).begin(); iter_list_string != (*iter_list_list_string).end(); iter_list_string++)
			{
				if (!not_terminator_if_is_empty(*iter_list_string))
				{//该表达式中有一个没法推出空  结束对该表达式的判断  换下一个表达式
					flag = false;
					break;
				}
			}
			if (flag)
			{//该句子推出了空  将左部压入栈中  判断下一个非终结符
				list_can_empty.push_back((*iter_list_struct).start_un);
				break;
			}
		}
	}
	list_can_empty.unique();
}

void exe2::show_foresee_table()	//显示预见表
{
	list<tmp_table_foresee>::iterator x;
	for (x = list_tmp_table_foresee.begin(); x != list_tmp_table_foresee.end(); x++)
	{
		list<string>::iterator tmp_i;
		for (tmp_i = (*x).content.begin(); tmp_i != (*x).content.end(); tmp_i++)
		{
			cout << "栈顶为 " << (*x).not_terminator << "  当前字符为" << (*tmp_i) << " 期望编号为" << (*x).number << "的表达式" << endl;
		}
	}
}

void exe2::print()
{

	list<string>::iterator x;
	for (x = list_SYN.begin(); x != list_SYN.end(); x++)
	{
		cout << (*x) << " ";
	}

	cout << setw(40) << cur_w << endl;

}

list<string> exe2::get_grammer(string left_not_terminator)//返回一个装着匹配的表达式（list形式）  形参是SYN的栈顶  cur_w(当前字符)是另一个隐形参数
{
	string thorw_x = "error :get_grammer()  can't find linked terminator";
	list<tmp_table_foresee>::iterator x;
	int  state_num = 0;
	string tmp_cur_w=cur_w;
	if (if_is_equal_i(cur_w))
	{
		
		tmp_cur_w = cur_w;
		cur_w = "i";		//将当前字符临时替换一下
	}
	for (x = list_tmp_table_foresee.begin(); x != list_tmp_table_foresee.end(); x++)
	{
		if ((*x).not_terminator == left_not_terminator)
		{//左部与预见表中的左部相同
			
			list<string>::iterator list_iter_content;
			for (list_iter_content = (*x).content.begin(); list_iter_content != (*x).content.end(); list_iter_content++)
			{
				
				if (cur_w == (*list_iter_content))
				{//匹配完成
					state_num = (*x).number;//得到句子的编码
					goto lable_break;
				}
			}

		}
	}

	throw thorw_x;
	//根据左部非终结符和句子编码找到 表达式
	//cout << "get_grammer() "<< left_not_terminator<<"   与 "<<cur_w<<" 对应的处理是" << state_num<<"号表达式"<<endl;
lable_break:	list<string> tmp;
	list<struct_exe>::iterator list_struct_iterator;
	list<list<string>>::iterator list_list_iter_string;
	for (list_struct_iterator = list_all_grammer.begin(); list_struct_iterator != list_all_grammer.end(); list_struct_iterator++)
	{
		if ((*list_struct_iterator).start_un == left_not_terminator)
		{//找到了
			//cout << "get_grammer() 中找到了左部" << (*list_struct_iterator).start_un << endl;
			list_list_iter_string = (*list_struct_iterator).SYN.begin();
			for (int i = 0; i < state_num - 1; i++)
			{
				//cout << "+++++++++++++++++++++++++++++++++++********************************************" << endl;
				list_list_iter_string++;

			}
			list<string>::iterator R;
			for (R = (*list_list_iter_string).begin(); R != (*list_list_iter_string).end(); R++)
			{
				//cout << (*R);
				tmp.push_back(*R);
			}
			break;
		}
	}
	//cout <<endl<< "get_grammer() over" << endl;
	cur_w = tmp_cur_w;
	return tmp;

}

void exe2::generate_table()//生成一个遇见表
{

	change_left_grammer();//左递归文法变换
	test_show_after_left_change();
	list<struct_exe>::iterator list_grammmer_iterator;
	for (list_grammmer_iterator = list_all_grammer.begin(); list_grammmer_iterator != list_all_grammer.end(); list_grammmer_iterator++)//遍历所有的语法左部
	{
		int number = 0;
		//cout << "generate_table() 当前正在处理" << (*list_grammmer_iterator).start_un << endl;
		list<list<string>>::iterator list_list_iterator;
		for (list_list_iterator = (*list_grammmer_iterator).SYN.begin(); list_list_iterator != (*list_grammmer_iterator).SYN.end(); list_list_iterator++)
		{
			tmp_table_foresee tmp_struct_x;
			tmp_struct_x.not_terminator = (*list_grammmer_iterator).start_un;
			tmp_struct_x.number = ++number;//生成该句子编号
			//cout << "generate_table() 当前正在查看的" << (*list_grammmer_iterator).start_un << "   find_first  " << (*list_list_iterator).front() << endl;
			tmp_struct_x.content = find_first((*list_grammmer_iterator).start_un, (*list_list_iterator).front());
			list_tmp_table_foresee.push_back(tmp_struct_x);
		}
	}
}

list<string> exe2::find_first(string Left, string A)//返回字符a的首字符
{

	//cout << "find_first（）" << Left << " 当前的字符串是" << A << endl;
	list<string> acc_list_string;	//返回这个字符的遇见字符
	acc_list_string.clear();
	//cout << "find_first (" << Left << "," << A << endl;
	if (A != "" && A[0] == '^')
		return acc_list_string;
	if (if_is_terminator(A))
	{//如果a是一个终结符
		acc_list_string.push_back(A);
		return acc_list_string;// 递归返回
	}

	if (A == "$" || not_terminator_if_is_empty(A))
	{
		//cout <<"\t\t\tfind_first()"<< A << "  为空 或 它可以推出空 now_find_first_left=" << Left << endl;
		now_find_first_left.push_back(Left);
		acc_list_string.merge(find_follow(Left));
		now_find_first_left.pop_back();
		return acc_list_string;//返回A的左部的后继符
	}

	if (if_is_not_terminator(A))
	{//A是一个非终结符
		//cout << "find_first()  "<<A<<" 是一个非终结符" << endl;
		list<struct_exe>::iterator tmp_iterator;

		for (tmp_iterator = list_all_grammer.begin(); tmp_iterator != list_all_grammer.end(); tmp_iterator++)
		{
			if ((*tmp_iterator).start_un == A)
			{//找到了A
				list<list<string>>::iterator list_list_iterator;

				list<string> tmp_cotent;
				tmp_cotent.clear();

				for (list_list_iterator = (*tmp_iterator).SYN.begin(); list_list_iterator != (*tmp_iterator).SYN.end(); list_list_iterator++)
				{
					string F = (*list_list_iterator).front();
					tmp_cotent = find_first(A, F);
					acc_list_string.merge(tmp_cotent);
				}
				goto lable_break;

			}
		}
	}
	else
	{
		string x = "erro  find_first() the \"" + A + "\" is not a not_terminator";
		throw x;
	}

lable_break: acc_list_string.unique();
	return acc_list_string;
}

list<string> exe2::find_follow(string a)//返回字符a的后继符
{
	//cout << "\t\t find_follow(  ) " <<a<< endl;
	list<struct_exe>::iterator list_all_grammer_iterator;

	list<string> acc_list_string, list_tmp;
	acc_list_string.clear();

	if (a == "E")
	{
		acc_list_string.push_back("#");
	}

	for (list_all_grammer_iterator = list_all_grammer.begin(); list_all_grammer_iterator != list_all_grammer.end(); list_all_grammer_iterator++)//语法总表遍历
	{
		list<list<string>>::iterator list_grammer_SYN_iterator;
		for (list_grammer_SYN_iterator = (*list_all_grammer_iterator).SYN.begin(); list_grammer_SYN_iterator != (*list_all_grammer_iterator).SYN.end(); list_grammer_SYN_iterator++)//某一左部的所有语法表达式遍历
		{
			list<string>::iterator list_string_iterator;
			for (list_string_iterator = (*list_grammer_SYN_iterator).begin(); list_string_iterator != (*list_grammer_SYN_iterator).end(); list_string_iterator++)//某一表达式中遍历
			{
				string now_find = (*list_string_iterator);

				if (now_find == a && now_find_first_left.back() != (*list_all_grammer_iterator).start_un)//&&后面的意思是不能又绕回到初始的状态  这样就会陷入递归死循环
				{//a存在 开始找符号 a的后继符
					//cout << "\t \tfind_follow()  找到的字符是" << now_find << endl;
					list<string>::iterator iter_next = list_string_iterator;

					iter_next++;//指向下一个字符

					if (iter_next == (*list_grammer_SYN_iterator).end())
					{//A是最后一个符号  后面没有字符
						//cout << " \tfind_follow()  A是最后一个符号  后面没有字符" << endl;
						now_find_first_left.push_back((*list_all_grammer_iterator).start_un);
						acc_list_string.merge(find_follow((*list_all_grammer_iterator).start_un));
						now_find_first_left.pop_back();
						acc_list_string.unique();
						continue;
					}

					//cout << "\t \tfind_follow()  下一个的字符是" << (*iter_next) << endl;
					/*
					if (a == "$")		//a是非终结符  永远不会为空
					{//A的后继符可以推出空
						//cout << " \tfind_follow() A的后继符可以推出空" << endl;
						acc_list_string.merge(find_follow((*list_all_grammer_iterator).start_un));
						acc_list_string.unique();
						continue;
					}
					*/
					if (if_is_terminator((*iter_next)))
					{//是一个终结符  返回该终结符即可
						//cout << " \tfind_follow() A是一个终结符  返回该终结符即可" << endl;
						list_tmp.push_back((*iter_next));
						acc_list_string.merge(list_tmp);
						acc_list_string.unique();
						continue;
					}

					//剩下的一个情况： a是一个非终结符  且不能循环  陷入死循环
					//if (now_find_first_left != (*list_all_grammer_iterator).start_un)
					{
						//cout << "********++++++++++++++++++++++++++*********" << now_find_first_left << "  " << (*list_all_grammer_iterator).start_un << endl;
						//cout << " \t find_follow() 剩下的一个情况： a是一个非终结符" << endl;
						acc_list_string.merge(find_first((*list_all_grammer_iterator).start_un, (*iter_next)));
						acc_list_string.unique();
					}
				}
			}
		}
	}
	//cout << "\t \tfind_follow() 结束++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" << endl;
	acc_list_string.unique();
	return acc_list_string;
}

void exe2::done_LL1(string start_not_terminator)	//开始LL1处理
{
	generate_table();
	show_foresee_table();

	find_can_empty_not_terminator();
	show_empty_list();
	cout << "开始翻译" << endl;
	cout << "栈\t\t\t\t\t\t" << "当前符号\t\t\t\t\t\t" << "生成的四元式" << endl;
	cur_w = get_w();
	list_SYN.push_back("#");//注意区分是从队列前压入还是后面压入  一律使用back
	list_SYN.push_back(start_not_terminator);
	while (!list_SYN.empty())//list_SYN栈不为空时一直进行
	{
		
		if ( if_is_equal_i( list_SYN.back()) )
		{
			
			list_stack_SEM.push_back(cur_w);
		}
		if (list_SYN.back()[0] == '^')		//捕获动作
		{
			//触发了动作   查看什么类型的动作  做出反应
			string a = list_SYN.back();
			string::iterator string_i = a.begin();
			a.erase(string_i);	//扔掉第一个动作标记符  ^
			done_two_opter(a);
			list_SYN.pop_back();
			continue;
		}
		print();
		if (list_SYN.back() == "$")
		{
			list_SYN.pop_back();
			if (list_SYN.empty() || wait_trans_expression.empty())
				break;
			cur_w = get_w();
		}

		if (list_SYN.back()=="i" && if_is_equal_i(cur_w)  || list_SYN.back() ==cur_w )
		{
			list_SYN.pop_back();
			if (list_SYN.empty() || wait_trans_expression.empty())
				break;
			//print();
			cur_w = get_w();

		}
		else
		{
			//SYN栈顶是非终结符 需要查表 将当前非终结符弹出 将匹配的表达式逆序入栈
			list<string> intermidate_list;
			intermidate_list.clear();
			intermidate_list = get_grammer(list_SYN.back());//送入非终结符
			//cout <<"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<< intermidate_list.front() << endl;
			if (intermidate_list.front() == "$")
				intermidate_list.pop_front();
			list_SYN.pop_back();
			while (!intermidate_list.empty())
			{
				list_SYN.push_back(intermidate_list.back());
				intermidate_list.pop_back();
			}
		}
	}

	if (wait_trans_expression.size() != 0)
		cout << "翻译失败" << endl;
	else
		cout << "翻译完成" << endl;

	show_list_QT(list_stack_QT);
}

bool exe2::sort_struct_exe2_start_un(const struct_exe & m1, const struct_exe& m2)
{
	return m1.start_un < m2.start_un;
}

void exe2::change_left_grammer()			//左递归文法变换
{
	list<struct_exe>::iterator testiterator;//所有表达式的迭代器
	for (testiterator = list_all_grammer.begin(); testiterator != list_all_grammer.end(); ++testiterator)	//遍历 找出左递归的语法 对所有文法进行遍历
	{
		//左递归的语法变换
		string expression_left = (*testiterator).start_un;

		list<list<string>>::iterator list_iterator;	//某一个左部的所有表达式迭代器
		bool if_exist_left = false; //是否存在左递归标志
		for (list_iterator = (*testiterator).SYN.begin(); list_iterator != (*testiterator).SYN.end(); ++list_iterator)	//对文法中的一个左部的所有语句进行遍历
		{
			if (expression_left == (*list_iterator).front())//存在左递归
			{
				if_exist_left = true;
				break;
			}
		}

		if (if_exist_left)//有左递归现象  开始处理
		{
			struct_exe new_not_termi;//新的生成式
			new_not_termi.start_un = expression_left + "1"; //A1
			list_string_not_terminator.push_back(expression_left + "1");
			list<list<string>> list_new_list_string;
			list<string> list_tmp;
			//
			//A代表原来的左部  A1代表新添加的左部
			//
			for (list_iterator = (*testiterator).SYN.begin(); list_iterator != (*testiterator).SYN.end(); ++list_iterator)	//对文法中的一个左部的所有语句进行遍历
			{
				if (expression_left != (*list_iterator).front())//首字符和左部不一样的句子 后面加上A1 左部仍是A
				{
					(*list_iterator).push_back(expression_left + "1");
				}
			}
			for (list_iterator = (*testiterator).SYN.begin(); list_iterator != (*testiterator).SYN.end();)	//对文法中的一个左部的所有语句进行遍历
			{
				list_tmp.clear();
				if (expression_left == (*list_iterator).front())//首字符和左部一样的句子 去掉A 后面加上A1 左部换为A1
				{
					list_tmp = (*list_iterator);
					list_tmp.pop_front();	//扔掉以前首字符相同的头部A
					list_tmp.push_back(expression_left + "1");	//将A1接在后面
					list_new_list_string.push_back(list_tmp);	//新生成的语句加入新的
					list_iterator = (*testiterator).SYN.erase(list_iterator);	//删除A中原来左递归的文法
					continue;
				}
				++list_iterator;
			}
			list_tmp.clear();
			list_tmp.push_back("$");	//代表空
			list_new_list_string.push_back(list_tmp);//表示加入了一个  A1->空; 语句
			new_not_termi.SYN = list_new_list_string;	//
			list_all_grammer.push_back(new_not_termi);	//将生成的文法加入总的文法表
		}
	}
}

void exe2::test_show_after_left_change()
{
	list<struct_exe>::iterator show_iter;
	for (show_iter = list_all_grammer.begin(); show_iter != list_all_grammer.end(); show_iter++)
	{

		list<list<string>>::iterator tmp;
		for (tmp = (*show_iter).SYN.begin(); tmp != (*show_iter).SYN.end(); tmp++)
		{
			cout << (*show_iter).start_un << "->";
			list<string>::iterator x;
			for (x = (*tmp).begin(); x != (*tmp).end(); x++)
			{
				cout << (*x) << " ";
			}
			cout << endl;
		}
	}
}

void exe2::add_expression(string string_express)		//添加表达式
{
	wait_trans_expression.push_back(string_express);
}

void exe2::add_struct_grammer(string fun_stat_un, list<list<string>> x)//形参 文法推导式左边的非终结符   推导式右边的所有推导式
{
	struct_exe se;
	se.start_un = fun_stat_un;
	int len = x.size();
	if (len == 0)
	{
		string err = "err the grammer is error,length is zero please input again";
		throw err;
	}
	se.SYN = x;
	se.number = ++sentence_number;	//给该条文法规则一个编号
	list_all_grammer.push_back(se);	//从后往前插 为了看着舒服
}

void exe2::start_done()		//递归下降
{
	try {
		fun_E();
	}
	catch (string x)
	{
		cout << x << endl;
		cout << "程序结束" << endl;
		return;
	}

	if (!wait_trans_expression.size())
		cout << "识别完成  字符串正确" << endl;
	else
		cout << "识别失败" << endl;
}

string exe2::get_w()	//获取一个字符串
{
	string x = wait_trans_expression.front();
	//cout << "get_w()当前获得的字符 w 为" << x << endl;
	wait_trans_expression.pop_front();
	return x;
}

//以下是递归 函数
void exe2::fun_start()//开始函数
{
	cur_w = get_w();
	fun_E();
	if (cur_w != "#")
		throw "erro at main process #";
	else
		return;
}
void exe2::fun_E()//子程序E
{
	fun_T();
	fun_E1();
}
void exe2::fun_T()//子程序T
{
	fun_F();
	fun_T1();
}
void exe2::fun_T1()//子程序T
{
	if (cur_w == "*")
	{
		cur_w = get_w();
		fun_F();
		fun_T1();
	}
	else
	{
		if (cur_w == "/")
		{
			cur_w = get_w();
			fun_F();
			fun_T1();
		}
	}
}
void exe2::fun_E1()//子程序E1
{
	if (cur_w == "+")
	{
		cur_w = get_w();
		fun_T();
		fun_E1();
	}
	else
	{
		if (cur_w == "-")
		{
			cur_w = get_w();
			fun_T();
			fun_E1();
		}
	}
}
void exe2::fun_F()//子程序F
{
	if (if_is_terminator(cur_w))
	{

	}
	else
	{
		if (cur_w == "(")
		{
			cur_w = get_w();
			fun_E();
			try
			{
				if (cur_w != ")")
				{
					string x = "err 3 at process F )";
					throw x;
				}
			}
			catch (char c)
			{
				cout << c << endl;
			}
		}
		else
		{
			string x = "err 2 at Process F (";
			throw x;
		}
	}
	cur_w = get_w();
}
//递归 函数  结束

bool exe2::if_is_not_terminator(string x)	//是否是一个非终结符 是 返回true
{
	list<string>::iterator FindIterator;
	//cout << "if_is_not_terminator()非终结符 当前判断的是" << x << "     ";
	for (FindIterator = list_string_not_terminator.begin(); FindIterator != list_string_not_terminator.end(); FindIterator++)
	{
		//cout << (*FindIterator) << "   ";
		if (x == (*FindIterator))
		{
			//cout << "是一个非终结符" << endl;
			return true;
		}

	}
	return false;
}

bool exe2::if_is_terminator(string x)	//是否是一个终结符 是 返回true
{
	list<string>::iterator FindIterator;
	for (FindIterator = list_string_terminator.begin(); FindIterator != list_string_terminator.end(); FindIterator++)
	{
		if (x == (*FindIterator))
			return true;

	}
	return false;
}

void exe2::test_left_change()		//用来测试一个左递归转换  也可以自己手动来修改
{
	cout << "+++++++++++++++++++++++++++++++++++++++调整左递归文法  测试+++++++++++++++" << endl;
	cout << "测试一个文法		T->b+c;			T->T+R;" << endl;
	cout << "变换后的结果应为   T->b + c T1;	T1->+R T;" << endl;
	list<list<string>> R;//一个左部的 所有右部 表达式
	list<string> r;    //一个文法表达式

	//测试一个文法		T->b+c;			T->T+R;   

	//变换后的结果应为  T->b + c T1;	T1->+R T;
	r.push_back("b");
	r.push_back("+");
	r.push_back("c");	//生成右部表达式 b+c；
	R.push_back(r);		//将这一个表达式加入到T的右部
	r.clear();
	r.push_back("T");
	r.push_back("+");
	r.push_back("R");//生成右部表达式 T+R；
	R.push_back(r);	//将这一个表达式加入到T的右部
	add_struct_grammer("T", R);	//将T的所有右部表达式 和T衔接起来
	change_left_grammer();
	test_show_after_left_change();
	//测试成功
	cout << "+++++++++++++++++++++++++++++++++++++++调整左递归文法  测试结束+++++++++++++++" << endl;
}

void exe2::test_digui()
{
	//递归下降 函数法  测试段
	wait_trans_expression.push_back("a");
	wait_trans_expression.push_back("*");
	wait_trans_expression.push_back("b");
	wait_trans_expression.push_back("*");
	wait_trans_expression.push_back("(");
	wait_trans_expression.push_back("a");
	wait_trans_expression.push_back("/");
	wait_trans_expression.push_back("c");
	wait_trans_expression.push_back("-");
	wait_trans_expression.push_back("b");
	wait_trans_expression.push_back(")");
	wait_trans_expression.push_back("#");


	//list_all_grammer.sort(sort_struct_exe2_start_un);
	try {
		fun_E();
	}
	catch (string x)
	{
		cout << x << endl;
		cout << "程序结束" << endl;
		return;
	}

	if (!wait_trans_expression.size())
		cout << "识别完成  字符串正确" << endl;
	else
		cout << "识别失败" << endl;

	//函数法  测试段结束
}


void add_grammer(exe2 &wkn)
{
	list<list<string>> R;
	list<string> exp;
	exp.push_back("T");
	R.push_back(exp);
	exp.clear();
	exp.push_back("E");
	exp.push_back("+");
	exp.push_back("T");
	exp.push_back("^+");

	R.push_back(exp);
	exp.clear();
	exp.push_back("E");
	exp.push_back("-");
	exp.push_back("T");
	exp.push_back("^-");
	R.push_back(exp);
	wkn.add_struct_grammer("E", R);

	R.clear();
	exp.clear();
	exp.push_back("F");
	R.push_back(exp);
	exp.clear();
	exp.push_back("T");
	exp.push_back("*");
	exp.push_back("F");
	exp.push_back("^*");
	R.push_back(exp);
	exp.clear();
	exp.push_back("T");
	exp.push_back("/");
	exp.push_back("F");
	exp.push_back("^/");
	R.push_back(exp);
	wkn.add_struct_grammer("T", R);

	R.clear();
	exp.clear();
	exp.push_back("I");

	R.push_back(exp);
	exp.clear();
	exp.push_back("(");
	exp.push_back("E");
	exp.push_back(")");
	R.push_back(exp);
	wkn.add_struct_grammer("F", R);

	R.clear();
	exp.clear();
	exp.push_back("i");
	R.push_back(exp);
	wkn.add_struct_grammer("I", R);
}

int main()
{
	//终结符

	word_kind data_cifa("D:\\编译原理\\编译原理\\wkn.txt");
	list<struct B>::iterator s_i = data_cifa.out_put.begin();

	


	list<string> tmp_terminator;

	list<string> equal_i;
	equal_i.clear();
	equal_i.push_back("i");
	tmp_terminator.clear();
	
	for (list<struct A>::iterator r = data_cifa.token_i.begin(); r != data_cifa.token_i.end(); r++)
	{
		//cout << "标识符" << (*r).name << endl;
		tmp_terminator.push_back((*r).name);
		equal_i.push_back((*r).name);
	}
	tmp_terminator.unique();

	for (list<struct A>::iterator r = data_cifa.token_c.begin(); r != data_cifa.token_c.end(); r++)
	{
		//cout << "常数" << (*r).name << endl;
		tmp_terminator.push_back((*r).name);
		equal_i.push_back((*r).name);
	}
	tmp_terminator.unique();

	for (list<struct A>::iterator r = data_cifa.token_p.begin(); r != data_cifa.token_p.end(); r++)
	{
		//cout << "界符" << (*r).name << endl;
		tmp_terminator.push_back((*r).name);
	}
	tmp_terminator.unique();

	list<string> not_terminator;
	not_terminator.push_back("E");
	not_terminator.push_back("H");
	not_terminator.push_back("T");
	not_terminator.push_back("F");
	not_terminator.push_back("W0");
	not_terminator.push_back("W1");
	not_terminator.push_back("I");
	tmp_terminator.push_back("(");		//加入终结符
	tmp_terminator.push_back(")");		//加入终结符
	tmp_terminator.push_back("+");		//加入终结符
	tmp_terminator.push_back("-");		//加入终结符
	tmp_terminator.push_back("*");		//加入终结符
	tmp_terminator.push_back("/");		//加入终结符
	tmp_terminator.push_back("#");		//加入终结符
	tmp_terminator.push_back("i");		//加入终结符

	tmp_terminator.unique();

	exe2 exe2_LL1(not_terminator,tmp_terminator);		//加入非终结符

	add_grammer(exe2_LL1);
	
	exe2_LL1.list_equal_i = equal_i;
	list<struct A>::iterator s_a_i;
	
	for (; s_i != data_cifa.out_put.end(); s_i++)
	{
		//cout << (*s_i).kind<<"  "<< (*s_i).id << endl;
		exe2_LL1.add_expression(data_cifa.reverse((*s_i).kind, (*s_i).id));
	}
	exe2_LL1.add_expression("#");		//添加表达式

	try {
		exe2_LL1.done_LL1("E");//将开始符号E填入其中
	}
	catch (string r)
	{
		cout << r << endl;
	}
	return 0;
}