* 找到則返回在名字表中的位置,否則返回0.
*
* idt:    要查找的名字
* tx:     當前名字表尾指針
*/
int position(char* idt, int tx)
{
	int i;
	strcpy(table[0].name, idt);
	i = tx;
	while (strcmp(table[i].name, idt) != 0)
	{
		i--;
	}
	return i;
}

/*
* 常量聲明處理
*/
int constdeclaration(int* ptx, int lev, int* pdx)
{
	if (sym == ident)
	{
		getsymdo;
		if (sym==eql || sym==becomes)
		{
			if (sym == becomes)
			{
				error(1);   /* 把=寫成了:= */
			}
			getsymdo;
			if (sym == number)
			{
				enter(constant, ptx, lev, pdx);
				getsymdo;
			}
			else
			{
				error(2);   /* 常量說明=后應是數字 */
			}
		}
		else
		{
			error(3);   /* 常量說明標識后應是= */
		}
	}
	else
	{
		error(4);   /* const后應是標識 */
	}
	return 0;
}

/*
* 變量聲明處理
*/
int vardeclaration(int* ptx,int lev,int* pdx)
{
	if (sym == ident)
	{
		enter(variable, ptx, lev, pdx); // 填寫名字表
		getsymdo;
	}
	else
	{
		error(4);   /* var后應是標識 */
	}
	return 0;
}

/*
* 輸出目標代碼清單
*/
void listcode(int cx0)
{
	int i;
	if (listswitch)
	{
		for (i=cx0; i<cx; i++)
		{
			printf("%d %s %d %d\n", i, mnemonic[code[i].f], code[i].l, code[i].a);
			fprintf(fa,"%d %s %d %d\n", i, mnemonic[code[i].f], code[i].l, code[i].a);
		}
	}
}

/*
* 語句處理
*/
int statement(bool* fsys, int* ptx, int lev)
{
	int i, cx1, cx2;
	bool nxtlev[symnum];

	if (sym == ident)   /* 準備按照賦值語句處理 */
	{
		i = position(id, *ptx);
		if (i == 0)
		{
			error(11);  /* 變量未找到 */
		}
		else
		{
			if(table[i].kind != variable)
			{
				error(12);  /* 賦值語句格式錯誤 */
				i = 0;
			}
			else
			{
				getsymdo;
				if(sym == becomes)
				{
					getsymdo;
				}
				else
				{
					error(13);  /* 沒有檢測到賦值符號 */
				}
				memcpy(nxtlev, fsys, sizeof(bool)*symnum);
				expressiondo(nxtlev, ptx, lev); /* 處理賦值符號右側表達式 */
				if(i != 0)
				{
					/* expression將執行一系列指令，但最終結果將會保存在棧頂，執行sto命令完成賦值 */
					gendo(sto, lev-table[i].level, table[i].adr);
				}
			}
		}//if (i == 0)
	}
	else
	{
		if (sym == readsym) /* 準備按照read語句處理 */
		{
			getsymdo;
			if (sym != lparen)
			{
				error(34);  /* 格式錯誤，應是左括號 */
			}
			else
			{
				do {
					getsymdo;
					if (sym == ident)
					{
						i = position(id, *ptx); /* 查找要讀的變量 */
					}
					else
					{
						i=0;
					}

					if (i == 0)
					{
						error(35);  /* read()中應是聲明過的變量名 */
					}
					else if (table[i].kind != variable)
					{
						error(32);	/* read()參數表的標識符不是變量, thanks to amd */
					}
					else
					{
						gendo(opr, 0, 16);  /* 生成輸入指令，讀取值到棧頂 */
						gendo(sto, lev-table[i].level, table[i].adr);   /* 儲存到變量 */
					}
					getsymdo;

				} while (sym == comma); /* 一條read語句可讀多個變量 */
			}
			if(sym != rparen)
			{
				error(33);  /* 格式錯誤，應是右括號 */
				while (!inset(sym, fsys))   /* 出錯補救，直到收到上層函數的后跟符號 */
				{
					getsymdo;
				}
			}
			else
			{
				getsymdo;
			}
		}
		else
		{
			if (sym == writesym)    /* 準備按照write語句處理，與read類似 */
			{
				getsymdo;
				if (sym == lparen)
				{
					do {
						getsymdo;
						memcpy(nxtlev, fsys, sizeof(bool)*symnum);
						nxtlev[rparen] = true;
						nxtlev[comma] = true;       /* write的后跟符號為) or , */
						expressiondo(nxtlev, ptx, lev); /* 調用表達式處理，此處與read不同，read為給變量賦值 */
						gendo(opr, 0, 14);  /* 生成輸出指令，輸出棧頂的值 */
					} while (sym == comma);
					if (sym != rparen)
					{
						error(33);  /* write()中應為完整表達式 */
					}
					else
					{
						getsymdo;
					}
				}
				gendo(opr, 0, 15);  /* 輸出換行 */
			}
			else
			{
				if (sym == callsym) /* 準備按照call語句處理 */
				{
					getsymdo;
					if (sym != ident)
					{
						error(14);  /* call后應為標識符 */
					}
					else
					{
						i = position(id, *ptx);
						if (i == 0)
						{
							error(11);  /* 過程未找到 */
						}
						else
						{
							if (table[i].kind == procedur)
							{
								gendo(cal, lev-table[i].level, table[i].adr);   /* 生成call指令 */
							}
							else
							{
								error(15);  /* call后標識符應為過程 */
							}
						}
						getsymdo;
					}
				}
				else
				{
					if (sym == ifsym)   /* 準備按照if語句處理 */
					{
						getsymdo;
						memcpy(nxtlev, fsys, sizeof(bool)*symnum);
						nxtlev[thensym] = true;
						nxtlev[dosym] = true;   /* 后跟符號為then或do */
						conditiondo(nxtlev, ptx, lev); /* 調用條件處理（邏輯運算）函數 */
						if (sym == thensym)
						{
							getsymdo;
						}
						else
						{
							error(16);  /* 缺少then */
						}
						cx1 = cx;   /* 保存當前指令地址 */
						gendo(jpc, 0, 0);   /* 生成條件跳轉指令，跳轉地址未知，暫時寫0 */
						statementdo(fsys, ptx, lev);    /* 處理then后的語句 */
						code[cx1].a = cx;   /* 經statement處理后，cx為then后語句執行完的位置，它正是前面未定的跳轉地址 */
					}
					else
					{
						if (sym == beginsym)    /* 準備按照復合語句處理 */
						{
							getsymdo;
							memcpy(nxtlev, fsys, sizeof(bool)*symnum);
							nxtlev[semicolon] = true;
							nxtlev[endsym] = true;  /* 后跟符號為分號或end */
							/* 循環調用語句處理函數，直到下一個符號不是語句開始符號或收到end */
							statementdo(nxtlev, ptx, lev);

							while (inset(sym, statbegsys) || sym==semicolon)
							{
								if (sym == semicolon)
								{
									getsymdo;
								}
								else
								{
									error(10);  /* 缺少分號 */
								}
								statementdo(nxtlev, ptx, lev);
							}
							if(sym == endsym)
							{
								getsymdo;
							}
							else
							{
								error(17);  /* 缺少end或分號 */
							}
						}
						else
						{
							if (sym == whilesym)    /* 準備按照while語句處理 */
							{
								cx1 = cx;   /* 保存判斷條件操作的位置 */
								getsymdo;
								memcpy(nxtlev, fsys, sizeof(bool)*symnum);
								nxtlev[dosym] = true;   /* 后跟符號為do */
								conditiondo(nxtlev, ptx, lev);  /* 調用條件處理 */
								cx2 = cx;   /* 保存循環體的結束的下一個位置 */
								gendo(jpc, 0, 0);   /* 生成條件跳轉，但跳出循環的地址未知 */
								if (sym == dosym)
								{
									getsymdo;
								}
								else
								{
									error(18);  /* 缺少do */
								}
								statementdo(fsys, ptx, lev);    /* 循環體 */
								gendo(jmp, 0, cx1); /* 回頭重新判斷條件 */
								code[cx2].a = cx;   /* 反填跳出循環的地址，與if類似 */
							}
							else
							{
								memset(nxtlev, 0, sizeof(bool)*symnum); /* 語句結束無補救集合 */
								testdo(fsys, nxtlev, 19);   /* 檢測語句結束的正確性 */
							}
						}
					}
				}
			}
		}
	}
	return 0;
}

/*
* 表達式處理
*/
int expression(bool* fsys, int* ptx, int lev)
{
	enum symbol addop;  /* 用于保存正負號 */
	bool nxtlev[symnum];

	if(sym==plus || sym==minus) /* 開頭的正負號，此時當前表達式被看作一個正的或負的項 */
	{
		addop = sym;    /* 保存開頭的正負號 */
		getsymdo;
		memcpy(nxtlev, fsys, sizeof(bool)*symnum);
		nxtlev[plus] = true;
		nxtlev[minus] = true;
		termdo(nxtlev, ptx, lev);   /* 處理項 */
		if (addop == minus)
		{
			gendo(opr,0,1); /* 如果開頭為負號生成取負指令 */
		}
	}
	else    /* 此時表達式被看作項的加減 */
	{
		memcpy(nxtlev, fsys, sizeof(bool)*symnum);
		nxtlev[plus] = true;
		nxtlev[minus] = true;
		termdo(nxtlev, ptx, lev);   /* 處理項 */
	}
	while (sym==plus || sym==minus)
	{
		addop = sym;
		getsymdo;
		memcpy(nxtlev, fsys, sizeof(bool)*symnum);
		nxtlev[plus] = true;
		nxtlev[minus] = true;
		termdo(nxtlev, ptx, lev);   /* 處理項 */
		if (addop == plus)
		{
			gendo(opr, 0, 2);   /* 生成加法指令 */
		}
		else
		{
			gendo(opr, 0, 3);   /* 生成減法指令 */
		}
	}
	return 0;
}

/*
* 項處理
*/
int term(bool* fsys, int* ptx, int lev)
{
	enum symbol mulop;  /* 用于保存乘除法符號 */
	bool nxtlev[symnum];

	memcpy(nxtlev, fsys, sizeof(bool)*symnum);
	nxtlev[times] = true;
	nxtlev[slash] = true;
	factordo(nxtlev, ptx, lev); /* 處理因子 */
	while(sym==times || sym==slash)
	{
		mulop = sym;
		getsymdo;
		factordo(nxtlev, ptx, lev);
		if(mulop == times)
		{
			gendo(opr, 0, 4);   /* 生成乘法指令 */
		}
		else
		{
			gendo(opr, 0, 5);   /* 生成除法指令 */
		}
	}
	return 0;
}

/*
* 因子處理
*/
int factor(bool* fsys, int* ptx, int lev)
{
	int i;
	bool nxtlev[symnum];
	testdo(facbegsys, fsys, 24);    /* 檢測因子的開始符號 */
	/* while(inset(sym, facbegsys)) */  /* 循環直到不是因子開始符號 */
	if(inset(sym,facbegsys))    /* BUG: 原來的方法var1(var2+var3)會被錯誤識別為因子 */
	{
		if(sym == ident)    /* 因子為常量或變量 */
		{
			i = position(id, *ptx); /* 查找名字 */
			if (i == 0)
			{
				error(11);  /* 標識符未聲明 */
			}
			else
			{
				switch (table[i].kind)
				{
				case constant:  /* 名字為常量 */
					gendo(lit, 0, table[i].val);    /* 直接把常量的值入棧 */
					break;
				case variable:  /* 名字為變量 */
					gendo(lod, lev-table[i].level, table[i].adr);   /* 找到變量地址并將其值入棧 */
					break;
				case procedur:  /* 名字為過程 */
					error(21);  /* 不能為過程 */
					break;
				}
			}
			getsymdo;
		}
		else
		{
			if(sym == number)   /* 因子為數 */
			{
				if (num > amax)
				{
					error(31);
					num = 0;
				}
				gendo(lit, 0, num);
				getsymdo;
			}
			else
			{
				if (sym == lparen)  /* 因子為表達式 */
				{
					getsymdo;
					memcpy(nxtlev, fsys, sizeof(bool)*symnum);
					nxtlev[rparen] = true;
					expressiondo(nxtlev, ptx, lev);
					if (sym == rparen)
					{
						getsymdo;
					}
					else
					{
						error(22);  /* 缺少右括號 */
					}
				}
				testdo(fsys, facbegsys, 23);    /* 因子后有非法符號 */
			}
		}
	}
	return 0;
}

/*
* 條件處理
*/
int condition(bool* fsys, int* ptx, int lev)
{
	enum symbol relop;
	bool nxtlev[symnum];

	if(sym == oddsym)   /* 準備按照odd運算處理 */
	{
		getsymdo;
		expressiondo(fsys, ptx, lev);
		gendo(opr, 0, 6);   /* 生成odd指令 */
	}
	else
	{
		/* 邏輯表達式處理 */
		memcpy(nxtlev, fsys, sizeof(bool)*symnum);
		nxtlev[eql] = true;
		nxtlev[neq] = true;
		nxtlev[lss] = true;
		nxtlev[leq] = true;
		nxtlev[gtr] = true;
		nxtlev[geq] = true;
		expressiondo(nxtlev, ptx, lev);
		if (sym!=eql && sym!=neq && sym!=lss && sym!=leq && sym!=gtr && sym!=geq)
		{
			error(20);
		}
		else
		{
			relop = sym;
			getsymdo;
			expressiondo(fsys, ptx, lev);
			switch (relop)
			{
			case eql:
				gendo(opr, 0, 8);
				break;
			case neq:
				gendo(opr, 0, 9);
				break;
			case lss:
				gendo(opr, 0, 10);
				break;
			case geq:
				gendo(opr, 0, 11);
				break;
			case gtr:
				gendo(opr, 0, 12);
				break;
			case leq:
				gendo(opr, 0, 13);
				break;
			}
		}
	}
	return 0;
}

/*
* 解釋程序
*/
void interpret()
{
	int p, b, t;    /* 指令指針，指令基址，棧頂指針 */
	struct instruction i;   /* 存放當前指令 */
	int s[stacksize];   /* 棧 */

	printf("start pl0\n");
	t = 0;
	b = 0;
	p = 0;
	s[0] = s[1] = s[2] = 0;
	do {
		i = code[p];    /* 讀當前指令 */
		p++;
		switch (i.f)
		{
		case lit:   /* 將a的值取到棧頂 */
			s[t] = i.a;
			t++;
			break;
		case opr:   /* 數學、邏輯運算 */
			switch (i.a)
			{
			case 0:
				t = b;
				p = s[t+2];
				b = s[t+1];
				break;
			case 1:
				s[t-1] = -s[t-1];
				break;
			case 2:
				t--;
				s[t-1] = s[t-1]+s[t];
				break;
			case 3:
				t--;
				s[t-1] = s[t-1]-s[t];
				break;
			case 4:
				t--;
				s[t-1] = s[t-1]*s[t];
				break;
			case 5:
				t--;
				s[t-1] = s[t-1]/s[t];
				break;
			case 6:
				s[t-1] = s[t-1]%2;
				break;
			case 8:
				t--;
				s[t-1] = (s[t-1] == s[t]);
				break;
			case 9:
				t--;
				s[t-1] = (s[t-1] != s[t]);
				break;
			case 10:
				t--;
				s[t-1] = (s[t-1] < s[t]);
				break;
			case 11:
				t--;
				s[t-1] = (s[t-1] >= s[t]);
				break;
			case 12:
				t--;
				s[t-1] = (s[t-1] > s[t]);
				break;
			case 13:
				t--;
				s[t-1] = (s[t-1] <= s[t]);
				break;
			case 14:
				printf("%d", s[t-1]);
				fprintf(fa2, "%d", s[t-1]);
				t--;
				break;
			case 15:
				printf("\n");
				fprintf(fa2,"\n");
				break;
			case 16:
				printf("?");
				fprintf(fa2, "?");
				scanf("%d", &(s[t]));
				fprintf(fa2, "%d\n", s[t]);
				t++;
				break;
			}
			break;
		case lod:   /* 取相對當前過程的數據基地址為a的內存的值到棧頂 */
			s[t] = s[base(i.l,s,b)+i.a];
			t++;
			break;
		case sto:   /* 棧頂的值存到相對當前過程的數據基地址為a的內存 */
			t--;
			s[base(i.l, s, b) + i.a] = s[t];
			break;
		case cal:   /* 調用子過程 */
			s[t] = base(i.l, s, b); /* 將父過程基地址入棧 */
			s[t+1] = b; /* 將本過程基地址入棧，此兩項用于base函數 */
			s[t+2] = p; /* 將當前指令指針入棧 */
			b = t;  /* 改變基地址指針值為新過程的基地址 */
			p = i.a;    /* 跳轉 */
			break;
		case inte:  /* 分配內存 */
			t += i.a;
			break;
		case jmp:   /* 直接跳轉 */
			p = i.a;
			break;
		case jpc:   /* 條件跳轉 */
			t--;
			if (s[t] == 0)
			{
				p = i.a;
			}
			break;
		}
	} while (p != 0);
}

/* 通過過程基址求上l層過程的基址 */
int base(int l, int* s, int b)
{
	int b1;
	b1 = b;
	while (l > 0)
	{
		b1 = s[b1];
		l--;
	}
	return b1;
}