temp.txt

一个编译器

  1055	
  1056	/**************************************************
  1057	* file: Parser.cpp
  1058	* date: 2006-04-12
  1059	* author: wuzuyang
  1060	* describe: parser
  1061	**************************************************/
  1062	
  1063	#define TRACE_DEBUG
  1064	
  1065	#ifdef TRACE_DEBUG
  1066		#define TRACE(FUNCTION) printf("%-16s token = %s\n", FUNCTION, currentToken.name);
  1067	#else
  1068		#define TRACE(A)
  1069	#endif
  1070	
  1071	
  1072	#include "Parser.h"
  1073	#include <stdio.h>
  1074	#include <stdlib.h>
  1075	
  1076	Parser::Parser(char* sourcefile){
  1077		lexer = new Lexer(sourcefile);
  1078		if(lexer->isReady())
  1079			currentToken = lexer->nextToken();
  1080	}
  1081	
  1082	Parser::~Parser(){
  1083		delete lexer;
  1084	}
  1085	
  1086	
  1087	Token Parser::nextToken(){
  1088		currentToken = lexer->nextToken();
  1089		return currentToken;
  1090	}
  1091	
  1092	void Parser::printError(const char *error){	// private method
  1093		printf("%s when token = '%s'\n", error, currentToken.name);
  1094	}
  1095	
  1096	void Parser::printError(){	// public method
  1097		if(lexer->isReady())
  1098			printf("\n*** ERROR BEFORE: ***\n%s", lexer->getSrc()+lexer->getIndex());
  1099		else
  1100			printf("Lexer is not ready!\n");
  1101	}
  1102	
  1103	/*==================================================================*/
  1104	
  1105	SyntaxTree* Parser::parse(){
  1106		if(lexer->isReady())
  1107			return Statement();
  1108		else
  1109			return NULL;
  1110	}
  1111	
  1112	
  1113	SyntaxTree* Parser::Statement(){
  1114		TRACE("in Statement();");
  1115		
  1116		SyntaxTree *tree = NULL;
  1117	
  1118		switch(currentToken.type){
  1119			case LEXER_DONE:
  1120				tree = new SyntaxTree(LEXER_DONE);
  1121				break;
  1122			case ID:
  1123				this->nextToken();
  1124				tree = Assign();
  1125				if(tree != NULL){
  1126					tree->addLeft(ID);
  1127				}
  1128				break;
  1129			case WHILE:
  1130				this->nextToken();
  1131				tree = While();
  1132				break;
  1133			case BEGIN:
  1134				this->nextToken();
  1135				tree = Block();
  1136				break;
  1137			case IF:
  1138				this->nextToken();
  1139				tree = Condition();
  1140				break;
  1141			default:
  1142				tree = NULL;
  1143				break;
  1144		}
  1145		
  1146		return tree;
  1147	}
  1148	
  1149	
  1150	SyntaxTree* Parser::Assign(){
  1151		TRACE("in Assign();");
  1152		
  1153		SyntaxTree *tree = NULL;
  1154	
  1155		if(currentToken.type == ASSIGN){
  1156			this->nextToken();
  1157			SyntaxTree *temptree = Expression();
  1158			
  1159			if(temptree != NULL){
  1160				tree = new SyntaxTree(ASSIGN);
  1161				tree->addRight(temptree);
  1162			}
  1163		}else{
  1164			this->printError("ERROR! Assignment statement expects '=';");
  1165			return NULL;
  1166		}
  1167		
  1168		return tree;
  1169	}
  1170	
  1171	
  1172	SyntaxTree* Parser::Expression(){
  1173		TRACE("in Expression();");
  1174	
  1175		SyntaxTree *temp = NULL;
  1176		SyntaxTree *tree = T();
  1177	
  1178		if(tree == NULL){
  1179			return NULL;
  1180		}
  1181		
  1182		while(currentToken.type == PLUS){
  1183			temp = new SyntaxTree(PLUS);
  1184			temp->addLeft(tree);
  1185			tree = temp;
  1186			this->nextToken();
  1187			
  1188			temp = T();
  1189			if(temp != NULL){
  1190				tree->addRight(temp);
  1191			}else{
  1192				this->printError("ERROR! Behind '+';");
  1193				return NULL;
  1194			}
  1195		}
  1196		
  1197		return tree;
  1198	}
  1199	
  1200	
  1201	SyntaxTree* Parser::T(){
  1202		SyntaxTree *temp = NULL;
  1203		SyntaxTree *tree = F();
  1204		
  1205		if(tree == NULL){
  1206			return NULL;
  1207		}
  1208		
  1209		while(currentToken.type == MUL){
  1210			temp = new SyntaxTree(MUL);
  1211			temp->addLeft(tree);
  1212			tree = temp;
  1213			this->nextToken();
  1214			
  1215			temp = F();
  1216			if(temp != NULL){
  1217				tree->addRight(temp);
  1218			}else{
  1219				this->printError("ERROR in T();");
  1220				return NULL;
  1221			}
  1222		}
  1223		
  1224		return tree;
  1225	}
  1226	
  1227	
  1228	SyntaxTree* Parser::F(){
  1229		SyntaxTree *tree = NULL;
  1230		
  1231		if(currentToken.type == ID){
  1232			tree = new SyntaxTree(ID);
  1233		}else if(currentToken.type == NUM){
  1234			tree = new SyntaxTree(NUM, atoi(currentToken.name));
  1235		}else{
  1236			this->printError("ERROR! in F();");
  1237		}
  1238		
  1239		this->nextToken();
  1240		
  1241		return tree;
  1242	}
  1243	
  1244	/*==================================================================*/
  1245	
  1246	SyntaxTree* Parser::Boolean(){
  1247		TRACE("in Boolean();");
  1248	
  1249		SyntaxTree *temp = NULL;
  1250		SyntaxTree *tree = T2();
  1251	
  1252		if(tree == NULL){
  1253			return NULL;
  1254		}
  1255		
  1256		while(currentToken.type == OR){
  1257			temp = new SyntaxTree(OR);
  1258			temp->addLeft(tree);
  1259			tree = temp;
  1260			this->nextToken();
  1261			
  1262			temp = T2();
  1263			if(temp != NULL){
  1264				tree->addRight(temp);
  1265			}else{
  1266				this->printError("ERROR! behind OR;");
  1267				return NULL;
  1268			}
  1269		}
  1270		
  1271		return tree;
  1272	}
  1273	
  1274	
  1275	SyntaxTree* Parser::T2(){
  1276		SyntaxTree *temp = NULL;
  1277		SyntaxTree *tree = F2();
  1278	
  1279		if(tree == NULL){
  1280			return NULL;
  1281		}
  1282		
  1283		while(currentToken.type == AND){
  1284			temp = new SyntaxTree(AND);
  1285			temp->addLeft(tree);
  1286			tree = temp;
  1287			this->nextToken();
  1288			
  1289			temp = F2();
  1290			if(temp != NULL){
  1291				tree->addRight(temp);
  1292			}else{
  1293				this->printError("ERROR! behind AND;");
  1294				return NULL;
  1295			}
  1296		}
  1297		
  1298		return tree;
  1299	}
  1300	
  1301	
  1302	SyntaxTree* Parser::F2(){
  1303		SyntaxTree *temp = NULL;
  1304		SyntaxTree *tree = Expression();
  1305		
  1306		if(tree == NULL){
  1307			return NULL;
  1308		}
  1309		
  1310		switch(currentToken.type){
  1311			case LT:
  1312				temp = new SyntaxTree(LT);
  1313				break;
  1314			case GT:
  1315				temp = new SyntaxTree(GT);
  1316				break;
  1317			case EQ:
  1318				temp = new SyntaxTree(EQ);
  1319				break;
  1320			default :
  1321				break;
  1322		}
  1323		
  1324		if(temp != NULL){
  1325			this->nextToken();
  1326			temp->addLeft(tree);
  1327			tree = temp;
  1328			temp = Expression();
  1329			if(temp != NULL){
  1330				tree->addRight(temp);
  1331			}else{
  1332				this->printError("ERROR! Relation Operator needs Expression behind;");
  1333				return NULL;
  1334			}
  1335		}
  1336	
  1337		return tree;
  1338	}
  1339	
  1340	/*==================================================================*/
  1341	
  1342	SyntaxTree* Parser::While(){
  1343		TRACE("in While();");
  1344	
  1345		SyntaxTree *tree = new SyntaxTree(WHILE);
  1346		SyntaxTree *temp = Boolean();
  1347		
  1348		if(temp == NULL){
  1349			this->printError("ERROR! in While(); Condition NULL;");
  1350			return NULL;
  1351		}
  1352		tree->addLeft(temp);
  1353		
  1354		if(currentToken.type != DO){
  1355			this->printError("ERROR! in While(); token.type!=DO;");
  1356			return NULL;
  1357		}
  1358		this->nextToken();
  1359		temp = Statement();
  1360	
  1361		if(temp == NULL){
  1362			this->printError("ERROR! in While(); DO empty;");
  1363			return NULL;
  1364		}
  1365		tree->addRight(temp);
  1366		
  1367		return tree;
  1368	}
  1369	
  1370	
  1371	/*==================================================================*/
  1372	
  1373	SyntaxTree* Parser::Begin(){
  1374		return Block();
  1375	}
  1376		
  1377	/********************************************
  1378		this version is for:
  1379		L->(S[^I])*S?	I: Identifier
  1380	********************************************/
  1381	SyntaxTree* Parser::Block(){
  1382		TRACE("in Block();");
  1383	
  1384		SyntaxTree *tree = NULL;
  1385		SyntaxTree *temp = NULL;
  1386		SyntaxTree *temp2 = NULL;
  1387		
  1388		while(currentToken.type != END){
  1389			if(currentToken.type == SEMI){
  1390				this->nextToken();
  1391			}else if(currentToken.type == LEXER_DONE){
  1392				this->printError("ERROR! begin without end.");
  1393				return NULL;
  1394			}else{
  1395				temp = Statement();
  1396				if(temp == NULL){	// don't accept NULL statement
  1397					this->printError("ERROR! Don't accept NULL statement.");
  1398					return NULL;
  1399				}else{
  1400					if(tree ==NULL){
  1401						tree = temp;
  1402					}else{
  1403						temp2 = new SyntaxTree(BEGIN);
  1404						temp2->addLeft(tree);
  1405						temp2->addRight(temp);
  1406						tree = temp2;
  1407					}
  1408				}
  1409			}
  1410		}
  1411		
  1412		this->nextToken();
  1413	
  1414		if(tree == NULL)
  1415			return NULL;
  1416		if(tree->getRight() == NULL)
  1417			return tree->getLeft();
  1418		else
  1419			return tree;
  1420	}
  1421	
  1422	
  1423	/********************************************
  1424		this version is for:
  1425		L->(S;)*S?
  1426	********************************************/
  1427	/*
  1428	SyntaxTree* Parser::Block(){
  1429		TRACE("in Block();");
  1430	
  1431		SyntaxTree *tree = Statement();//NULL;
  1432		SyntaxTree *temp = NULL;
  1433		SyntaxTree *temp2 = NULL;
  1434		
  1435		while(currentToken.type != END){
  1436			if(currentToken.type == SEMI){
  1437				TRACE("SEMI");
  1438				this->nextToken();
  1439	
  1440				temp = Statement();
  1441				if(temp == NULL){	// don't accept NULL statement
  1442					this->printError("ERROR! Don't accept NULL statement.");
  1443					return NULL;
  1444				}else{
  1445					if(tree ==NULL){
  1446						tree = temp;
  1447					}else{
  1448						temp2 = new SyntaxTree(BEGIN);
  1449						temp2->addLeft(tree);
  1450						temp2->addRight(temp);
  1451						tree = temp2;
  1452					}
  1453				}
  1454			}else if(currentToken.type == LEXER_DONE){
  1455				this->printError("ERROR! begin without end.");
  1456				return NULL;
  1457			}else{
  1458				this->printError("ERROR! begin without end.");
  1459				return NULL;
  1460			}
  1461		}
  1462	
  1463		this->nextToken();
  1464	
  1465		if(tree == NULL)
  1466			return NULL;
  1467		if(tree->getRight() == NULL)
  1468			return tree->getLeft();
  1469		else
  1470			return tree;
  1471	}
  1472	*/
  1473	
  1474	
  1475	/*==================================================================*/
  1476	
  1477	
  1478	SyntaxTree* Parser::Condition(){
  1479		TRACE("in Condition();");
  1480		
  1481		SyntaxTree *tree = new SyntaxTree(IF);
  1482		SyntaxTree *temp = Boolean();
  1483		SyntaxTree *temp2 = NULL;
  1484		
  1485		if(temp == NULL){
  1486			this->printError("ERROR! if without a boolean statement.");
  1487			return NULL;
  1488		}
  1489		tree->addLeft(temp);
  1490		
  1491		if(currentToken.type != THEN){
  1492			this->printError("ERROR! if without then.");
  1493			return NULL;
  1494		}
  1495		this->nextToken();
  1496		temp = Statement();
  1497		
  1498		if(temp == NULL){
  1499			this->printError("ERROR! then without a statement.");
  1500			return NULL;
  1501		}
  1502		temp2 = temp;
  1503		
  1504		if(currentToken.type == ELSE){
  1505			this->nextToken();
  1506			temp = new SyntaxTree(BEGIN);
  1507			temp->addLeft(temp2);
  1508			temp2 = temp;
  1509			
  1510			temp = Statement();
  1511			if(temp == NULL){
  1512				this->printError("ERROR! else without a statement.");
  1513				return NULL;
  1514			}
  1515			temp2->addRight(temp);
  1516		}
  1517		
  1518		tree->addRight(temp2);
  1519		
  1520		return tree;
  1521	}
  1522	
  1523	
  1524	
  1525	
  1526	/**************************************************
  1527	* file: main.cpp
  1528	* author: wuzuyang
  1529	* describe: for test
  1530	**************************************************/
  1531	
  1532	#include <stdio.h>
  1533	#include "Parser.h"
  1534	
  1535	int main(int argc, char* argv[]){
  1536		char *filename = "test.txt";
  1537		char *fileout = NULL;
  1538		
  1539		if(argc > 1){
  1540			filename = argv[1];
  1541		}
  1542		
  1543		if(argc > 2){
  1544			fileout = argv[2];
  1545		}
  1546		
  1547		FILE *fp = fopen(fileout, "w");
  1548		Parser parser = Parser(filename);
  1549		SyntaxTree *tree = parser.parse();
  1550	
  1551		if(tree!=NULL){
  1552			printf("\n************= Tree =****************:\n");
  1553			tree->display();
  1554			if(fp != NULL) tree->display(fp);
  1555		}else{
  1556			parser.printError();
  1557		}
  1558		
  1559		if(fp != NULL) fclose(fp);
  1560		
  1561		printf("\n");
  1562		
  1563		return 0;
  1564	}
  1565	
  1566	
  1567	
  1568	/************************************************************
  1569	* file: Lexer.cpp
  1570	* date: 2006-03-31
  1571	* author: wuzuyang
  1572	* describe: none;
  1573	*************************************************************/
  1574	
  1575	#include "Lexer.h"
  1576	#include <stdio.h>
  1577	#include <string.h>
  1578	
  1579	#define MAXRESERVED 7
  1580	#define TOKENBUFSIZE 64
  1581