main.cpp

slr语法分析器

{
	int temp, j, k;
	initize();
	ofstream out("semantic.txt");
	position = headToken;
	stateStack.push(27);
	tokenStack.push(-1);
	termStack.push(0);
	while(actionTable[termStack.top()][position->id] != -1) {
		temp = actionTable[termStack.top()][position->id];
		if(temp == 0) {
			out << "there are some errors";
			return;
		} else {
			if( temp/1000 != 0) {
				char* c = NULL;
				c = terminative(position->id);
				out << "move in " << c << endl;
				stateStack.push(position->id);
				termStack.push(temp%1000);
				tokenStack.push(position->entry);
				position = position->next;
			} else {
				panner(temp);
				out<<"use generate expression "<<grammar[temp].id<<" "<<grammar[temp].string<<"  execute"<<endl;
				if(!empty(temp) ) {
					for(j = 0;j < grammar[temp].length; j++) {
						stateStack.pop();
						termStack.pop();
						tokenStack.pop();
					}
				}
				k = nonTerminative(grammar[temp].left);
				stateStack.push(k);
				tokenStack.push(-1);
				j = termStack.top();
				termStack.push(gotoTable[j][k]);
			}
		}
	}
	f1();
	out<<"use generate expression "<<grammar[1].id<<" "<<grammar[1].string<<"  execute"<<endl;
	out<<"analyse over"<<endl;
}
//回填
void backPatch(int i ,int j)
{
	int q = i;
	char* k;
	int n = -1;
	char buffer[16];
	k = equalExp[q].forth;
	if(!isdigit(k[0])) return;
	else {
		if(i >= j) return;
		else {
			n = atoi(k);
			itoa(j, buffer, 10);
			while(equalExp[q].id != n) {
				k = equalExp[q].forth;
				n = atoi(k);
				strcpy(equalExp[n].forth,buffer);
				q = n;
			}
			strcpy(equalExp[n].forth, buffer);
		}
	}
}
int merger(int i,int j)
{
	int p, n;
	char *k;
	char buffer[16];
	if(j == nextQuad || !j)
		return i;
	else {
		p = j;
		k = equalExp[p].forth;
		if(isdigit(k[0])) n=atoi(k);
		while(equalExp[p].id != n) {
			k = equalExp[p].forth;
			if(isdigit(k[0])) n=atoi(k);
		}
		itoa(i, buffer, 10);
		strcpy(equalExp[p].forth, buffer);
		return p;
	}
}
//***********************************  panner  *****************************************
void panner(int i)
{
	switch(i) {
	case  1: { f1(); break;  case  2:  f2(); break;  case  3:  f3(); break;  case  4:  f4(); break;}
	case  5: { f5(); break;  case  6:  f6(); break;  case  7:  f7(); break;  case  8:  f8(); break;}
	case  9: { f9(); break;  case 10: f10(); break;  case 11: f11(); break;  case 12: f12(); break;}
	case 13: {f13(); break;  case 14: f14(); break;  case 15: f15(); break;  case 16: f16(); break;}
	case 17: {f17(); break;  case 18: f18(); break;  case 19: f19(); break;  case 20: f20(); break;}
	case 21: {f21(); break;  case 22: f22(); break;  case 23: f23(); break;  case 24: f24(); break;}
	case 25: {f25(); break;  case 26: f26(); break;  case 27: f27(); break;  case 28: f28(); break;}
	case 29: {f29(); break;  case 30: f30(); break;  case 31: f31(); break;  case 32: f32(); break;}
	case 33: {f33(); break;  case 34: f34(); break;  case 35: f35(); break;}
	default: break;}
	return;
}

void f1()
{
	backPatch(nextList_L, nextQuad);
	equalExp[nextQuad].id = nextQuad;
	strcpy(equalExp[nextQuad].first, "end");
	equalExp[nextQuad].second[0] = '\0';
	equalExp[nextQuad].third[0] = '\0';
	strcpy(equalExp[nextQuad].forth, "0");
	nextQuad++;
}

void f2()
{
	backPatch(nextList_L, quad_M);
	nextList_L = nextList_S;
}
void f3()
{
	nextList_L = nextList_S;
}
void f4()
{
	quad_M = nextQuad;
}
void f5()
{
	nextList_S = nextList_L;
}
void f6()
{
	char buffer[10];
	backPatch(nextList_S, nextQuad);
	nextList_S = nextList_U;
	equalExp[nextQuad].id = nextQuad;
	strcpy(equalExp[nextQuad].first, "j");
	equalExp[nextQuad].second[0] = '\0';
	equalExp[nextQuad].third[0] = '\0';
	itoa( head_U,buffer, 10);
	strcpy(equalExp[nextQuad].forth, buffer);
	nextQuad++;
}
void f7()
{
	nextList_U = falseList_B;
	backPatch(trueList_B, nextQuad);
	head_U = head_W;
}

void f8()
{
	head_W = nextQuad;
}

void f9()
{
	nextList_C = falseList_B;
	backPatch(trueList_B, nextQuad);
}

void f10()
{
	int temp;
	char buffer[10];
	nextList_F = nextList_S;
	temp = nextQuad;
	equalExp[nextQuad].id = nextQuad;
	strcpy(equalExp[nextQuad].first, "j");
	equalExp[nextQuad].second[0] = '\0';
	equalExp[nextQuad].third[0] = '\0';
	itoa(temp,buffer, 10);
	strcpy(equalExp[nextQuad].forth, buffer);
	nextQuad++;

	nextList_F = merger(temp, nextList_F);
	temp = nextList_C;
	backPatch(temp, nextQuad);
}

void f11()
{
	nextList_S = merger(nextList_C, nextList_S);
}

void f12()
{
	nextList_S = merger(nextList_F, nextList_S);
}

void f13()				//search and fill symbol table
{
	entryType* temp;
	for(int i = 0; i < num_D; i++)
	{
		temp = headEntry;
		while(list_D[i] != temp->address) temp=temp->next;
		temp->type=type_T;					//S->TD
	}
	nextList_S=nextQuad;
}

void f14()
{
	strcpy(type_T, "int");
}

void f15()
{
	list_D[num_D] = tokenStack.top();
	num_D++;
}

void f16()
{
	num_D = 0;
	list_D[0] = tokenStack.top();
	num_D++;
}

void f17()
{
	entryType *temp;
	char buffer[10] = {0};
	equalExp[nextQuad].id = nextQuad;
	strcpy(equalExp[nextQuad].first, "=");
	strcpy(equalExp[nextQuad].second, place_E[num_E-1]);
	num_E--;
	place_E[num_E][0] = '\0';
	equalExp[nextQuad].third[0] = '\0';
	int t[5], tempEntry;
	for(i = 0; i < 3; i++) {
		t[i] = tokenStack.top();
		tokenStack.pop();
	}
	tempEntry = tokenStack.top();
	for(i = 2; i >= 0; i--) tokenStack.push(t[i]);
	temp = headEntry;
	while(tempEntry != temp->address) temp=temp->next;
	strcpy(equalExp[nextQuad].forth, temp->idName);
	nextQuad++;
	nextList_S = nextQuad;
}

void f18()
{
	falseList_B = merger(falseList_N, falseList_B);
}

void f19()
{
	backPatch(trueList_B, nextQuad);
	falseList_N = falseList_B;
}
void f20()
{
	trueList_B = merger(trueList_P, trueList_B);
}
void f21()
{
	backPatch(falseList_B, nextQuad);
	trueList_P = trueList_B;
}
void f22()
{
	int temp;
	temp = falseList_B;
	falseList_B = trueList_B;
	trueList_B = temp;
}
void f23()
{

}

void f24()
{
	int temp;
	char buffer[10];
	temp = nextQuad;
	equalExp[nextQuad].id = nextQuad;
	strcpy(equalExp[nextQuad].first, "j");
	equalExp[nextQuad].second[0] = '\0';
	equalExp[nextQuad].third[0] = '\0';
	itoa(temp, buffer, 10);
	strcpy(equalExp[nextQuad].forth, buffer);
	nextQuad++;

	trueList_B = temp;
	falseList_B = 0;
}

void f25()
{
	int temp;
	char buffer[10];
	temp = nextQuad;
	equalExp[nextQuad].id = nextQuad;
	strcpy(equalExp[nextQuad].first, "j");
	equalExp[nextQuad].second[0] = '\0';
	equalExp[nextQuad].third[0] = '\0';
	itoa(temp,buffer, 10);
	strcpy(equalExp[nextQuad].forth, buffer);
	nextQuad++;
	falseList_B = temp;
	trueList_B = 0;
}
void f26()
{
	int temp;
	char buffer[10];
	entryType* eCursor;
	temp = nextQuad;
	equalExp[nextQuad].id = nextQuad;
	strcpy(equalExp[nextQuad].first, relop);
	int t[5];
	for(i=0;i<2;i++) {
		t[i] = tokenStack.top();
		tokenStack.pop();
	}
	int tempDigit = tokenStack.top();
	for(i = 1; i >= 0; i--) tokenStack.push(t[i]);
	eCursor = headEntry;
	while(tempDigit != eCursor->address)
		eCursor = eCursor->next;	//查找符号表
	strcpy(equalExp[nextQuad].second, eCursor->idName);
	strcpy(equalExp[nextQuad].third, place_E[num_E-1]);
	num_E--;
	place_E[num_E][0] = '\0';
	itoa(temp,buffer, 10);
	strcpy(equalExp[nextQuad].forth, buffer);
	nextQuad++;

	trueList_B=temp;
	equalExp[nextQuad].id = nextQuad;
	strcpy(equalExp[nextQuad].first, "j");
	equalExp[nextQuad].second[0] = '\0';
	equalExp[nextQuad].third[0] = '\0';

	itoa(temp+1, buffer,10);
	strcpy(equalExp[nextQuad].forth, buffer);
	nextQuad++;
	falseList_B = temp + 1;

}
void f27()
{
	strcpy(relop, "j<");
}

void f28()
{
	strcpy(relop, "j<=");
}

void f29()
{
	strcpy(relop, "j==");
}

void f30()
{
	strcpy(	relop, "j<>");
}

void f31()
{
	char buffer[8];
	equalExp[nextQuad].id = nextQuad;
	strcpy(equalExp[nextQuad].first, "+");
	strcpy(	equalExp[nextQuad].second, place_E[num_E-2]);
	strcpy( equalExp[nextQuad].third, place_E[num_E-1]);
	place_E[--num_E][0] = '\0';
	place_E[--num_E][0] = '\0';
	strcpy(equalExp[nextQuad].forth, "t");
	itoa(tempNum+1, buffer, 10);
	strcat(equalExp[nextQuad].forth, buffer);
	strcpy(tempVariable[tempNum++], equalExp[nextQuad].forth);
	strcpy(place_E[num_E++], tempVariable[tempNum-1]);
	nextQuad++;
}

void f32()
{
	char buffer[8];
	equalExp[nextQuad].id = nextQuad;
	strcpy(equalExp[nextQuad].first, "*");
	strcpy(	equalExp[nextQuad].second, place_E[num_E-2]);
	strcpy( equalExp[nextQuad].third, place_E[num_E-1]);
	place_E[--num_E][0] = '\0';
	place_E[--num_E][0] = '\0';
	strcpy(equalExp[nextQuad].forth, "t");
	itoa(tempNum+1, buffer,10);
	strcat(equalExp[nextQuad].forth, buffer);
	strcpy(tempVariable[tempNum++], equalExp[nextQuad].forth);
	strcpy(place_E[num_E++], tempVariable[tempNum-1]);
	nextQuad++;
}

void f33()
{
	char buffer[5];
	equalExp[nextQuad].id = nextQuad;
	strcpy(equalExp[nextQuad].first, "=");
	strcpy(equalExp[nextQuad].second, place_E[num_E-1]);
	place_E[--num_E][0] = '\0';
	equalExp[nextQuad].third[0] = '\0';
	strcpy(equalExp[nextQuad].forth, "t");
	itoa( tempNum + 1, buffer, 10);
	strcat(equalExp[nextQuad].forth, buffer);
	strcpy(tempVariable[tempNum++], equalExp[nextQuad].forth);
	strcpy(place_E[num_E++], tempVariable[tempNum - 1]);
	nextQuad++;
}

void  f34()
{
	entryType* eCursor;
	int i = tokenStack.top();
	eCursor = headEntry;
	while(eCursor->address != i) eCursor = eCursor->next;
	if(eCursor->type!=NULL) strcpy(place_E[num_E++], eCursor->idName);
	else {
		strcpy(place_E[num_E++], eCursor->idName);
		cout<< eCursor->idName << "not declared" <<endl;
	}
}

void f35()
{
	char buffer[10];
	digitTable* dCursor;
	int i = tokenStack.top();
	dCursor = headDigit;
	while(dCursor->address != i) dCursor = dCursor->next;
	itoa(dCursor->digit, buffer, 10);
	strcpy(place_E[num_E], buffer);
	num_E++;
}

void output()
{
	ofstream idFile("id.txt");
	entryType * tempEntry = headEntry ;
	while(tempEntry) {
		idFile << tempEntry->address << '\t' << tempEntry->idName << '\t';
		if(!tempEntry->type) idFile<< endl ;
		else idFile<<tempEntry->type<<endl;
		tempEntry = tempEntry->next ;
	}
	ofstream constFile("const.txt");
	digitTable* tempDigit=headDigit;
	while(tempDigit) {
		constFile <<tempDigit->address<<'\t'<< tempDigit->digit<<endl;
		tempDigit = tempDigit->next;
	}
	ofstream tokenFile("token.txt") ;
	tokenType* tempToken = headToken ;
	while(tempToken) {
		tokenFile << tempToken->id << '\t' << tempToken->entry << '\t'<<endl;
		tempToken = tempToken->next;
	}
	FILE * emitFile;
	emitFile=fopen("emit.txt","w");
	for(int i = 0; i < nextQuad; i++) {

		fprintf(emitFile,"%s,",equalExp[i].first);
		if(equalExp[i].second[0] == 0)
             fprintf(emitFile," ,");
		else fprintf(emitFile,"%s,",equalExp[i].second);
		if( equalExp[i].third[0] == 0)
             fprintf(emitFile," ,");
		else fprintf(emitFile,"%s,",equalExp[i].third);
		fprintf(emitFile,"%s\n",equalExp[i].forth);
	}
	cout<<"Please check id.txt, token.txt, const.txt, semantic.txt, emit.txt"<<endl;
}

int main()
{
	init();
	scanner();
	analyse();
	output();

	return 0;
}