yufa.cpp

自定义简单语法类C语言编译器

				}
				else	
				{Retract();
				cout<<"$STAR";
				tok[wordnum].ttype=GT;
				tok[wordnum].str=">";
				tok[wordnum].line=filelinenum;
				cout<<"$GT";
				}
		}
		else if(ch=='<')
				{GetChar();
				if(ch=='=')
				{
					tok[wordnum].ttype=LTEQ;
					tok[wordnum].str="RLT";
					tok[wordnum].line=filelinenum;
					cout<<"$LTEQ";
				}
				else	
				{Retract();
				tok[wordnum].ttype=LT;
				tok[wordnum].str="LT";
				tok[wordnum].line=filelinenum;
				cout<<"$LT";
				}
		}
		else if(ch==';')
				{
				tok[wordnum].ttype=SEMI;
				tok[wordnum].str=";";
				tok[wordnum].line=filelinenum;
				cout<<"$SEMI";
				}
		else if(ch==',')
				{
				tok[wordnum].ttype=COMMA;
				tok[wordnum].str=",";
				tok[wordnum].line=filelinenum;
				cout<<"$COMMA";
				}
		else if(ch=='(')
				{
				tok[wordnum].ttype=LPAREN;
				tok[wordnum].str="(";
				tok[wordnum].line=filelinenum;
				cout<<"$LPAREN";
				}
		else if(ch==')')
				{
				tok[wordnum].ttype=RPAREN;
				tok[wordnum].str=")";
				tok[wordnum].line=filelinenum;
				cout<<"$RPAREN";
				}
		else if(ch=='{')
				{
				tok[wordnum].ttype=LBRACE;
				tok[wordnum].str="{";
				tok[wordnum].line=filelinenum;
				cout<<"$LBRACE";
				}
		else if(ch=='}')
				{
				tok[wordnum].ttype=RBRACE;
				tok[wordnum].str="}";
				tok[wordnum].line=filelinenum;
				cout<<"$RBRACE";
				}
		else if(ch=='[')
				{
				tok[wordnum].ttype=LSQUAR;
				tok[wordnum].str="[";
				tok[wordnum].line=filelinenum;
				cout<<"$RBRACE";
				}
		else if(ch==']')
				{
				tok[wordnum].ttype=RSQUAR;
				tok[wordnum].str="]";
				tok[wordnum].line=filelinenum;
				cout<<"$RBRACE";
				}
		else if(ch=='!')
				{GetChar();
					if(ch=='=')
					{
						tok[wordnum].ttype=NEQ;
						tok[wordnum].str="!=";
						tok[wordnum].line=filelinenum;
						cout<<"$NEQ";
					}
					else  
					{
						Retract();
						cout<<"词法error";
						return 0;
					}
				}
		else if(ch=='~')
				{
				tok[wordnum].ttype=WAVE;
				tok[wordnum].str='~';
				tok[wordnum].line=filelinenum;
				cout<<"$WAVE";
				}
		else if(ch==0)
		{
			i++;
			return 1;
		}
		else {
				cout<<"词法error";
				return 0;
			}
		for(t=0;t<j;t++)
			strToken[t]=null;
		wordnum++;
		toktype=tok[wordnum-1].ttype;
		cout<<" ";
		cfoutfile<<"<token line=\""<<filelinenum<<"\" type=\""<<type[toktype]<<"\" string=\""<<tok[wordnum-1].str<<"\" />"<<"\n	";
		return 1;
		}

int cifa()
	{
	ifstream infile("chengxu.txt");
	int scanright;
	string str,str2;
	infile>>str2;
	if(!str2.length())
	{cout<<"文件为空"<<endl;
	return 0;
	}
	infile.seekg(0,ios::beg);
	cfoutfile<<"<?xml version=\"1.0\"?>\n<root>\n	";
 	while(!infile.eof())
	{   
		i=0;
		memset(read,0,50);
		std::getline(infile,str);
		str.copy(read,str.length());
		cout<<read<<"   ";
		filelinenum++;
		while(i<strlen(read))
		{
			scanright=scan();
			if(!scanright)
				return 0;
		}
		cout<<endl;
	}
	cfoutfile<<"</root>";
	infile.close();
	cfoutfile.close();
	return 1;
}

//语法分析函数定义（用到tok数组）
NodeList CreateTreeNode()
{
 	NodeList newnode=(NodeList)malloc(sizeof(TreeNode));
	newnode->ntype=OTHER;
	newnode->child[0]=NULL;
	newnode->child[1]=NULL;
	newnode->child[2]=NULL;
	newnode->sibling=NULL;
	memset(newnode->rettype,0,10);
	memset(newnode->nodestr,0,10);
	memset(newnode->vartype,0,10);
	return newnode;
}

void printerror()
{
	if(yufaright)
	{
		cout<<"程序第"<<tok[yf_wordnum].line<<"行"<<tok[yf_wordnum].str<<"出错"<<endl;
	tempwordnum=yf_wordnum;
	yufaright=0;
	exit(1);
	}
}

//匹配单词串类型
int match(TokenType ttype)
{
	if(ttype==tok[yf_wordnum].ttype)
	{
		yf_wordnum++;
		return 1;
	}
	else {
			printerror();
		return 0;
	}
}


//fun-declaration→ type-specifier ID( params ) compound-stmt
NodeList fun_decla()
{	
	NodeList curnode=CreateTreeNode();
	if(tok[yf_wordnum].ttype==INT)
		match(INT);
	else match(VOID);
	if(match(ID))
	{
		curnode->ntype=FunDecl;
		tok[yf_wordnum-2].str.copy(curnode->rettype,tok[yf_wordnum-2].str.length());
		tok[yf_wordnum-1].str.copy(curnode->nodestr,tok[yf_wordnum-1].str.length());
		curnode->lineno=tok[yf_wordnum-1].line;
	}
	match(LPAREN);
	NodeList curnode2=CreateTreeNode();
	curnode2=params();
	match(RPAREN);
	NodeList curnode3=CreateTreeNode();
	curnode3=compound_stmt();
	curnode->child[0]=curnode2;
	curnode->child[1]=curnode3;
	//if(curnode2==0)
	//	cout<<"fuck";
	return curnode;
}

// var-declaration->int ID [ [ NUM ] ] ;
NodeList var_decla()
{
	NodeList curnode=CreateTreeNode();
	match(INT);
	match(ID);
	if(tok[yf_wordnum].ttype==LSQUAR)
	{	
		tok[yf_wordnum-2].str.copy(curnode->vartype,tok[yf_wordnum-2].str.length());
		curnode->ntype=VarDecl;
		curnode->lineno=tok[yf_wordnum-1].line;
		curnode->isarray=1;
		tok[yf_wordnum-1].str.copy(curnode->nodestr,tok[yf_wordnum-1].str.length());
		match(LSQUAR);
		match(NUMBER);
		NodeList curnode2=CreateTreeNode();
		curnode2->lineno=tok[yf_wordnum].line;
		curnode2->ntype=ConstID;
		tok[yf_wordnum-1].str.copy(curnode2->nodestr,tok[yf_wordnum-1].str.length());
		curnode->child[0]=curnode2;
		match(RSQUAR);
	}
	else{
		tok[yf_wordnum-1].str.copy(curnode->nodestr,tok[yf_wordnum-1].str.length());
		tok[yf_wordnum-2].str.copy(curnode->vartype,tok[yf_wordnum-2].str.length());
		curnode->ntype=VarDecl;
		curnode->lineno=tok[yf_wordnum-1].line;
		curnode->isarray=0;
	}
	match(SEMI);
	return curnode;
}

//	params → param-list | void
NodeList params()
{
	NodeList curnode=CreateTreeNode();
	if(tok[yf_wordnum].ttype==INT)
	{
		curnode=param_list();
	}
		return curnode;
}

//param-list→ param { , param }
NodeList param_list()
{
	NodeList rootnode=CreateTreeNode();
	NodeList tempnode=rootnode;
	while(tok[yf_wordnum].ttype==INT)
	{
		NodeList curnode=CreateTreeNode();
		curnode=param();
		tempnode->sibling=curnode;
		tempnode=curnode;
		if(tok[yf_wordnum].ttype==COMMA)
		match(COMMA);
	}
	return rootnode->sibling;
}

//param->int ID [ [ ] ]
NodeList param()
{
	NodeList curnode=CreateTreeNode();
	match(INT);
	match(ID);
	curnode->isarray=0;
	curnode->lineno=tok[yf_wordnum-1].line;
	curnode->ntype=Para;
	tok[yf_wordnum-1].str.copy(curnode->nodestr,tok[yf_wordnum-1].str.length());
	tok[yf_wordnum-2].str.copy(curnode->vartype,tok[yf_wordnum-2].str.length());
	if(tok[yf_wordnum].ttype==LSQUAR)
	{
		match(LSQUAR);
		match(RSQUAR);
		curnode->isarray=1;
	}
	else curnode->isarray=0;
	return curnode;
}

//compound-stmt→ { local-declarations  statement-list }
NodeList compound_stmt()
{
	NodeList rootnode=CreateTreeNode();
	NodeList tempnode=rootnode;
	match(LBRACE);
	while(tok[yf_wordnum].ttype==INT||tok[yf_wordnum].ttype==IF||tok[yf_wordnum].ttype==WHILE||
		tok[yf_wordnum].ttype==RETURN||tok[yf_wordnum].ttype==ID||tok[yf_wordnum].ttype==LBRACE)
	{	
		NodeList curnode1=CreateTreeNode();
		if(tok[yf_wordnum].ttype==INT)
			{
		
				curnode1=local_decla();
				while(tempnode->sibling!=0)
					tempnode=tempnode->sibling;
				tempnode->sibling=curnode1;
				tempnode=curnode1;
			}
		if(tok[yf_wordnum].ttype==IF||tok[yf_wordnum].ttype==WHILE||tok[yf_wordnum].ttype==RETURN
			||tok[yf_wordnum].ttype==ID||tok[yf_wordnum].ttype==LBRACE)
			{
			NodeList curnode1=CreateTreeNode();
				curnode1=statement_list();
				while(tempnode->sibling!=0)
					tempnode=tempnode->sibling;
				tempnode->sibling=curnode1;
				tempnode=curnode1;
			}
	}
	match(RBRACE);
	rootnode=rootnode->sibling;
	return rootnode;
}

//local-declarations ->{ var-declaration }
NodeList local_decla()
{
	NodeList rootnode=CreateTreeNode();
	NodeList tempnode=rootnode;
	while(tok[yf_wordnum].ttype==INT)
	{
		NodeList curnode1=CreateTreeNode();
		curnode1= var_decla();
		tempnode->sibling=curnode1;
		tempnode=curnode1;
	}
	rootnode=rootnode->sibling;
	return rootnode;
	
}

//statement-list->{ statement }
NodeList statement_list()
{
	NodeList rootnode=CreateTreeNode();
	NodeList tempnode=rootnode;
	while(tok[yf_wordnum].ttype==INT||tok[yf_wordnum].ttype==IF||tok[yf_wordnum].ttype==WHILE||
		tok[yf_wordnum].ttype==ID||tok[yf_wordnum].ttype==LBRACE||tok[yf_wordnum].ttype==RETURN)
	{
		NodeList curnode1=CreateTreeNode();
		curnode1= statement();
		tempnode->sibling=curnode1;
		tempnode=curnode1;
	}
	rootnode=rootnode->sibling;
	return rootnode;
}

//statement→ expression-stmt∣compound-stmt∣selection-stmt∣iteration-stmt∣return-stmt
NodeList statement()
{
	NodeList curnode=CreateTreeNode();
	switch(tok[yf_wordnum].ttype)
	{
			
	case IF:
		curnode=if_stmt();
		break;
	case RETURN:
		curnode= return_stmt();
		break;
	case WHILE:
		curnode= while_stmt();
		break;
	case LBRACE:
		curnode= compound_stmt();
		break;
	default:
		curnode= exp_stmt();
	}
	return curnode;
}

//return-stmt-> return [expression] ;
NodeList  return_stmt()
{
	NodeList curnode=CreateTreeNode();
	match(RETURN);
	tok[yf_wordnum-1].str.copy(curnode->nodestr,tok[yf_wordnum-1].str.length());
	if(tok[yf_wordnum].ttype==ID||tok[yf_wordnum].ttype==NUMBER||tok[yf_wordnum].ttype==LPAREN)
	{
		NodeList curnode1=CreateTreeNode();
		curnode1= exp();
		curnode->child[0]=curnode1;
	}
	curnode->ntype=ReturnStm;
	curnode->lineno=tok[yf_wordnum-1].line;
	match(SEMI);
	return curnode;
}

//selection-stmt-> if ( expression ) statement [ else statement ]
NodeList  if_stmt()
{
	NodeList curnode=CreateTreeNode();
	match(IF);
	curnode->ntype=IfStm;
	tok[yf_wordnum-1].str.copy(curnode->nodestr,tok[yf_wordnum-1].str.length());
	curnode->lineno=tok[yf_wordnum-1].line;
	match(LPAREN);
	NodeList curnode1=CreateTreeNode();
	curnode1= exp();
	match(RPAREN);
	NodeList curnode2=CreateTreeNode();
	curnode2= statement();
	curnode->ntype=IfStm;
	if(tok[yf_wordnum].ttype==ELSE)
	{
		match(ELSE);
		NodeList curnode3=CreateTreeNode();
	    curnode3= statement();
		curnode->child[2]=curnode3;
		curnode->ntype=IfElseStm;
	}
	curnode->child[0]=curnode1;
	curnode->child[1]=curnode2;
	return curnode;
}

//iteration-stmt→ while( expression ) statement
NodeList  while_stmt()
{
	NodeList curnode=CreateTreeNode();
	match(WHILE);
	curnode->ntype=WhileStm;
	tok[yf_wordnum-1].str.copy(curnode->nodestr,tok[yf_wordnum-1].str.length());
	curnode->lineno=tok[yf_wordnum-1].line;
	match(LPAREN);
	NodeList curnode1=CreateTreeNode();
	curnode1= exp();
	match(RPAREN);
	NodeList curnode2=CreateTreeNode();
	curnode2= statement();
	curnode->child[0]=curnode1;
	curnode->child[1]=curnode2;
	return curnode;
}

//expression-stmt->[ expression ] ;
NodeList  exp_stmt()
{
	NodeList curnode=CreateTreeNode();
	if(tok[yf_wordnum].ttype==ID||tok[yf_wordnum].ttype==NUMBER)
	{
		curnode=exp();
	}
	match(SEMI);
	return curnode;
}

//expression→ var = expression | simple-expression
NodeList  exp()
{
	NodeList curnode=CreateTreeNode();
	if(tok[yf_wordnum+1].ttype==ASSIGN)
	{
		NodeList curnode1=CreateTreeNode();
		curnode1= var();
		match(ASSIGN);
		tok[yf_wordnum-1].str.copy(curnode->nodestr,tok[yf_wordnum-1].str.length());
		NodeList curnode2=CreateTreeNode();
		curnode2= exp();
		curnode->ntype=AssignStm;
		curnode->child[0]=curnode1;
		curnode->child[1]=curnode2;
		curnode->lineno=tok[yf_wordnum-1].line;
	}
	else curnode=simple_expression();
	return curnode;
}


//var->ID [ [ expression ] ]
NodeList  var()
{
	NodeList curnode=CreateTreeNode();
	match(ID);
	curnode->ntype=VarID;
	tok[yf_wordnum-1].str.copy(curnode->nodestr,tok[yf_wordnum-1].str.length());
    curnode->lineno=tok[yf_wordnum-1].line;
	if(tok[yf_wordnum].ttype==LSQUAR)
	{
		match(LSQUAR);
		NodeList curnode1=CreateTreeNode();
		curnode1= exp();
		match(RSQUAR);
		curnode->child[0]=curnode1;
		curnode->isarray=1;
		return curnode;
	}
	curnode->isarray=0;
	return curnode;
}

//simple-expression-> additive-expression [ relop additive-expression ]
NodeList  simple_expression()
{
	NodeList curnode1=CreateTreeNode();
	NodeList rootnode=CreateTreeNode();
	curnode1= additive_expression();
	if(tok[yf_wordnum].ttype==LT||tok[yf_wordnum].ttype==LTEQ||tok[yf_wordnum].ttype==GT||
		tok[yf_wordnum].ttype==GTEQ||tok[yf_wordnum].ttype==EQ||tok[yf_wordnum].ttype==NEQ)
	{
		NodeList curnode=CreateTreeNode();
		curnode=relop();
		NodeList curnode2=CreateTreeNode();
		curnode2=additive_expression();