bylr.c

本次实验

			i++;
		}
		fclose(in);
	}

	for(i = 1; i < 15; i++) {
		int end = 0;
		int j = 0, k = 0;
		while(grammar[i].string[j] == ' ' && grammar[i].string[j] != '\0')
			j++;
		grammar[i].left = grammar[i].string[j++];
		while(grammar[i].string[j] == ' '&& grammar[i].string[j] != '\0')
			j++;
		if(grammar[i].string[j] == '-'&& grammar[i].string[j] != '>')
			j += 2;
		else {
			printf("there are some errors in grammar!\n");
			return;
		}
		while(grammar[i].string[j] == ' ')
			j++;
		while( grammar[i].string[j] != '\0') {
			while(grammar[i].string[j] != ' ') {
				if(grammar[i].string[j] == '\0' ) {
					end = 1;
					break;
				} else j++;
			}
			if(!end) {
				k++;
				j++;
			}
		}
		grammar[i].length = k + 1;
	}
}
//判断是否为空动作并处理
int empty(int i)
{
	int j = 0, k = 0;
	int len = 0;
	char temp[16];
	char *str = "epsilon";

	len = strlen(grammar[i].string) - 1;
	if(grammar[i].length == 1) {
		j = len-1;
		while(grammar[i].string[j] != ' ')
			j--;
		j++;
		for (;j<len;j++)
		{
			temp[k] = grammar[i].string[j];
			k++;
		}
		temp[k] = '\0';
		if(!strcmp(temp,str))
			return 1;
	}
	return 0;
}
//判断是否为非终结符
int isNonTerminative(char ch)
{
	int i;
	for(i = 0; i < 10; i++) {
		if(ch == nonTerminate[i].character)
			return i;
	}
	return -1;
}
//判断是否为终结符
char* isTerminative(int i)
{
	int j;
	for(j = 0; j < 15; j++) {
		if(record[j].id == i)
			return record[j].symbol;
	}
	return NULL;
}

//初始化非终结符
void initize()
{
	FILE *noter;
	if((noter = fopen("nonTerminative.txt","rt")) == NULL) {
		printf("Cannot open file.\n");
		exit(1);
	}
	else {
		for(i = 0; i < 10; i++)
			fscanf(noter, "%d  %c", &nonTerminate[i].id, &nonTerminate[i].character);
	}
	fclose(noter);

	readGrammar();
	memset(equalExp, 0, sizeof(equalExp));
}


void Analyse(Stack stateStack,Stack termStack,Stack tokenStack)
{
	int temp, j, k;
	initize();

	printf("\n\n\n--------------语法分析----------------\n");
	position = headToken;
	Push(13,stateStack);
	Push(-1,tokenStack);
	Push(0,termStack);
	while(actionTable[Top(termStack)][position->id] != -1) {
		temp = actionTable[Top(termStack)][position->id];
		if(temp == 0)
			return;
		else {
			if(temp/1000 != 0) {
				char* c = NULL;
				c = isTerminative(position->id);
				Push(position->id,stateStack);
				Push(temp%1000,termStack);
				Push(position->entry,tokenStack);
				position = position->next;
			}
			else {
				panner(temp,tokenStack);
				if(!empty(temp)) {
					for(j = 0;j < grammar[temp].length; j++) {
						Pop(stateStack);
						Pop(termStack);
						Pop(tokenStack);
					}
				}
				k = isNonTerminative(grammar[temp].left);
				Push(k,stateStack);
				Push(-1,tokenStack);
				j = Top(termStack);
				Push(gotoTable[j][k],termStack);
			}
		}
	}
}
//回填
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);
		}
	}
}


void panner(int i,Stack tokenStack)
{
	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(tokenStack); break;
		case  8: f8(tokenStack); break;
		case  9: f9(tokenStack); break;
		case 10: f10(); break;
		case 11: f11(); break;
		case 12: f12(); break;
		case 13: f13(tokenStack); break;
		case 14: f14(tokenStack); break;
		default: break;
	}
	return;
}

void f1()
{
	backPatch(nextList_P, 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_P, quad_M);
	nextList_P = nextList_S;
}
void f3()
{
	nextList_P = nextList_D;
}
void f4()
{
	quad_M = nextQuad;
}

void f5()
{
	struct entryType* temp;
	int i;
	for(i = 0; i < num_L; i++)
	{
		temp = headEntry;
		while(list_L[i] != temp->address) temp=temp->next;
		temp->type=type_T;
	}
	nextList_D=nextQuad;
}

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

void f7(Stack tokenStack)
{
	list_L[num_L] = Top(tokenStack);
	num_L++;
}

void f8(Stack tokenStack)
{
	num_L = 0;
	list_L[0] = Top(tokenStack);
	num_L++;
}

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

void f10()
{
	char buffer[8];
	int sum;
	equalExp[nextQuad].id = nextQuad;
	strcpy(equalExp[nextQuad].first, "+");
	strcpy(equalExp[nextQuad].second, place_E[num_E-2].strName);
	strcpy(equalExp[nextQuad].third, place_E[num_E-1].strName);
	//printf("%d\n",place_E[num_E-2].value);
	//printf("%d\n",place_E[num_E-1].value);
	sum = place_E[num_E-2].value + place_E[num_E-1].value;
	//printf("%d\n",sum);
	strcpy(place_E[--num_E].strName," ");
	place_E[num_E].value = 0;
	strcpy(place_E[--num_E].strName," ");
	place_E[num_E].value = 0;
	strcpy(equalExp[nextQuad].forth, "t");
	itoa(tempNum+1, buffer, 10);
	strcat(equalExp[nextQuad].forth, buffer);
	strcpy(tempVariable[tempNum++], equalExp[nextQuad].forth);
	place_E[num_E].value = sum;
	strcpy(place_E[num_E++].strName, tempVariable[tempNum-1]);
	nextQuad++;
}

void f11()
{
	char buffer[8];
	int product;
	equalExp[nextQuad].id = nextQuad;
	strcpy(equalExp[nextQuad].first, "*");
	strcpy(equalExp[nextQuad].second, place_E[num_E-2].strName);
	strcpy(equalExp[nextQuad].third, place_E[num_E-1].strName);
	//printf("%d\n",place_E[num_E-2].value);
	//printf("%d\n",place_E[num_E-1].value);
	product = place_E[num_E-2].value * place_E[num_E-1].value;
	//printf("%d\n",product);
	strcpy(place_E[--num_E].strName," ");
	place_E[num_E].value = 0;
	strcpy(place_E[--num_E].strName," ");
	place_E[num_E].value = 0;
	strcpy(equalExp[nextQuad].forth, "t");
	itoa(tempNum+1, buffer,10);
	strcat(equalExp[nextQuad].forth, buffer);
	strcpy(tempVariable[tempNum++], equalExp[nextQuad].forth);
	place_E[num_E].value = product;
	strcpy(place_E[num_E++].strName, tempVariable[tempNum-1]);
	nextQuad++;
}

void f12()
{
	return ;
}

void  f13(Stack tokenStack)
{
	struct entryType* eCursor;
	int i = Top(tokenStack);
	eCursor = headEntry;
	while(eCursor->address != i)
		eCursor = eCursor->next;
	if(eCursor->type!=NULL){
		place_E[num_E].value = eCursor->value;
		strcpy(place_E[num_E++].strName, eCursor->idName);	
	}
	else {
		place_E[num_E].value = eCursor->value;
		strcpy(place_E[num_E++].strName, eCursor->idName);	
		printf("%s not declared\n",eCursor->idName);
	}
}

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

void Output()
{
	int i;
	struct entryType* tempEntry = headEntry;
	struct digitTable* tempDigit = headDigit;
	struct tokenType* tempToken = headToken;

	printf("\n\t变量名表\n");
	printf("-----------------------------\n");
	printf("序号\t变量名\t类型\t值\n");
	while(tempEntry) {
		printf("%d\t%s\t",tempEntry->address,tempEntry->idName);
		if(!tempEntry->type)
			printf("\n");
		else
			printf("%s\t%d\n",tempEntry->type,tempEntry->value);
		tempEntry = tempEntry->next ;
	}

	printf("\n\n\n--------四元式--------\n");
	for(i = 0; i < nextQuad; i++) {
		printf("( %s,",equalExp[i].first);
		if(equalExp[i].second[0] == 0)
             printf("    ,");
		else printf("%4s,",equalExp[i].second);
		if( equalExp[i].third[0] == 0)
             printf("    ,");
		else printf("%4s,",equalExp[i].third);
		printf("%4s )\n",equalExp[i].forth);
	}
}

int main()
{
	Stack stateStack,termStack,tokenStack;

	stateStack=CreateStack();
	termStack=CreateStack();
	tokenStack=CreateStack();
	headEntry = tailEntry = NULL;
	headDigit = tailDigit = NULL;
	headToken = tailToken = NULL;
	Scan();
	Analyse(stateStack,termStack,tokenStack);
	Output();

	return 0;
}