temp.txt

一个编译器

   528		}// end while
   529		
   530		if(next==false){
   531			index --;
   532		}
   533		
   534		if(bufindex == TOKENBUFSIZE - 1){
   535			// OUT OF BUFFER! It should never happen.
   536			token.type = ERROR;
   537			token.name = "OUT OF BUFFER!";
   538		}
   539		
   540		if(bufindex!=0){
   541			buf[bufindex] = '\0';
   542			token.name = new char[bufindex];
   543			strcpy(token.name, buf);
   544			if(token.type==ID){	// looking for reserved word and set the right type
   545				reservedLookup(token);
   546			}
   547		}
   548		
   549		return token;
   550	}
   551	
   552	
   553	// looking for reserved word and set the right type
   554	void reservedLookup(Token &token){
   555		for(int i=0;i<MAXRESERVED;i++){
   556			if(strcmp(token.name, ReservedWords[i].name)==0){
   557				token.type = ReservedWords[i].type;
   558				if(token.type == BEGIN)
   559					token.name = "{";
   560				if(token.type == END)
   561					token.name = "}";
   562				break;
   563			}
   564		}
   565	}
   566	
   567	
   568	void getSingleOperator(char c, Token &token){
   569		switch(c){
   570			case '{':
   571				token.type = BEGIN;
   572				token.name = "{";
   573				break;
   574			case '}':
   575				token.type = END;
   576				token.name = "}";
   577				break;
   578			case '+':
   579				token.type = PLUS;
   580				token.name = "+";
   581				break;
   582			case '*':
   583				token.type = MUL;
   584				token.name = "*";
   585				break;
   586			case '#':
   587			case '\0':	// end of file
   588				token.type = LEXER_DONE;
   589				token.name = "FINISH";
   590				break;
   591			case '&':
   592				token.type = AND;
   593				token.name = "&";
   594				break;
   595			case '|':
   596				token.type = OR;
   597				token.name = "|";
   598				break;
   599			case ';':
   600				token.type = SEMI;
   601				token.name = ";";
   602				break;
   603			default:
   604				token.type = ERROR;
   605				token.name = "ERROR! Unknown character.";
   606				printf("Error occured when state=START! Current character is: %c\n", c);
   607				break;
   608		}
   609	}
   610	
   611	
   612	
   613	/************************************************************
   614	* file: SyntaxTreeNode.h
   615	* date: 2006-04-12
   616	* author: wuzuyang
   617	* describe: none; SyntaxTreeNode
   618	*************************************************************/
   619	
   620	#include <stdio.h>
   621	#include "common.h"
   622	
   623	class SyntaxTreeNode{
   624	private:
   625		TokenType type;
   626		int value;	// identifiers will be given distinguish values.
   627		SyntaxTreeNode *left, *right, *child3;
   628		
   629	public:
   630		SyntaxTreeNode();
   631		SyntaxTreeNode::SyntaxTreeNode(TokenType t, int val);
   632		~SyntaxTreeNode();
   633		
   634		void setType(TokenType t);
   635		void setValue(int val);
   636		
   637		TokenType getType();
   638		int getValue();
   639		
   640		void addLeft(TokenType t, int val);
   641		// add the subtree n to this tree's left
   642		void addLeft(SyntaxTreeNode *n);
   643		
   644		void addRight(TokenType t, int val);
   645		// add the subtree n to this tree's right
   646		void addRight(SyntaxTreeNode *n);
   647		
   648		void addChild3(TokenType t, int val);
   649		// add the subtree n to this tree's child3
   650		void addChild3(SyntaxTreeNode *n);
   651		
   652		SyntaxTreeNode* getRootNode();
   653		
   654		SyntaxTreeNode* getLeft();
   655		SyntaxTreeNode* getRight();
   656		SyntaxTreeNode* getChild3();
   657		
   658		friend class SyntaxTree;
   659	};
   660	
   661	
   662	
   663	/************************************************************
   664	* file: SyntaxTreeNode.cpp
   665	* date: 2006-04-12
   666	* author: wuzuyang
   667	* describe: none; SyntaxTreeNode
   668	*************************************************************/
   669	
   670	#include "SyntaxTreeNode.h"
   671	
   672	
   673	SyntaxTreeNode::SyntaxTreeNode(){
   674		type = ERROR;
   675		value = 0;
   676		left = right = child3 = NULL;
   677	}
   678	SyntaxTreeNode::SyntaxTreeNode(TokenType t, int val){
   679		type = t;
   680		value = val;
   681		left = right = child3 = NULL;
   682	}
   683	
   684	SyntaxTreeNode::~SyntaxTreeNode(){
   685	}
   686	
   687	/*===================================================================*/
   688	
   689	void SyntaxTreeNode::setType(TokenType t){
   690		type = t;
   691	}
   692	
   693	TokenType SyntaxTreeNode::getType(){
   694		return type;
   695	}
   696	
   697	void SyntaxTreeNode::setValue(int val){
   698		value = val;
   699	}
   700	
   701	int SyntaxTreeNode::getValue(){
   702		return value;
   703	}
   704	
   705	
   706	void SyntaxTreeNode::addLeft(TokenType t, int val){
   707		left = new SyntaxTreeNode(t, val);
   708	}
   709	void SyntaxTreeNode::addLeft(SyntaxTreeNode *n){
   710		left = n;
   711	}
   712	
   713	
   714	void SyntaxTreeNode::addRight(TokenType t, int val){
   715		right = new SyntaxTreeNode(t, val);
   716	}
   717	void SyntaxTreeNode::addRight(SyntaxTreeNode *n){
   718		right = n;
   719	}
   720	
   721	
   722	void SyntaxTreeNode::addChild3(TokenType t, int val){
   723		child3 = new SyntaxTreeNode(t, val);
   724	}
   725	void SyntaxTreeNode::addChild3(SyntaxTreeNode *n){
   726		child3 = n;
   727	}
   728	
   729	
   730	SyntaxTreeNode* SyntaxTreeNode::getLeft(){
   731		return left;
   732	}
   733	
   734	SyntaxTreeNode* SyntaxTreeNode::getRight(){
   735		return right;
   736	}
   737	
   738	SyntaxTreeNode* SyntaxTreeNode::getChild3(){
   739		return child3;
   740	}
   741	
   742	
   743	
   744	/************************************************************
   745	* file: SyntaxTree.h
   746	* date: 2006-04-12
   747	* author: wuzuyang
   748	* describe: none; SyntaxTree
   749	*************************************************************/
   750	
   751	#include "common.h"
   752	#include "SyntaxTreeNode.h"
   753	
   754	class SyntaxTree{
   755	private:
   756		SyntaxTreeNode *root;
   757		
   758	public:
   759		SyntaxTree(TokenType t, int val=0);
   760		// make a new root node with the same type and val as n, but not other
   761		SyntaxTree(SyntaxTreeNode *n);
   762		SyntaxTree(SyntaxTree *tree);
   763		SyntaxTree();	// with root->type = ERROR
   764		~SyntaxTree();
   765		
   766		void display(FILE *fo=stdout);
   767		void display(SyntaxTreeNode *n, int tabcount, FILE *fo=stdout);
   768		
   769		void setRootNode();
   770		void setRootNode(TokenType t, int val=0);
   771		// make a new root node with the same type and val as n, but not other
   772		void setRootNode(SyntaxTreeNode *n);
   773		
   774		void addLeft(TokenType t, int val=0);
   775		// add the subtree n to this tree's left
   776		void addLeft(SyntaxTree *n);
   777		
   778		void addRight(TokenType t, int val=0);
   779		// add the subtree n to this tree's right
   780		void addRight(SyntaxTree *n);
   781		
   782		void addChild3(TokenType t, int val=0);
   783		// add the subtree n to this tree's child3
   784		void addChild3(SyntaxTree *n);
   785		
   786		SyntaxTreeNode* getRootNode();
   787		
   788		SyntaxTree* getLeft();
   789		SyntaxTree* getRight();
   790		SyntaxTree* getChild3();
   791	
   792	};
   793	
   794	
   795	
   796	/************************************************************
   797	* file: SyntaxTree.cpp
   798	* date: 2006-04-12
   799	* author: wuzuyang
   800	* describe: none; SyntaxTree
   801	*************************************************************/
   802	
   803	#include <stdio.h>
   804	#include <string.h>
   805	#include "SyntaxTree.h"
   806	
   807	
   808	char* tokenToString(TokenType type);
   809	
   810	/*======================================================================*/
   811	
   812	SyntaxTree::SyntaxTree(TokenType t, int val){
   813		root = new SyntaxTreeNode(t, val);
   814	}
   815	SyntaxTree::SyntaxTree(SyntaxTreeNode *n){
   816		setRootNode(n);
   817	}
   818	SyntaxTree::SyntaxTree(SyntaxTree *tree){
   819		setRootNode(tree->getRootNode());
   820	}
   821	SyntaxTree::SyntaxTree(){
   822		setRootNode();
   823	}
   824	
   825	SyntaxTree::~SyntaxTree(){
   826		// implement it later.
   827	}
   828	
   829	/*====================================================================*/
   830	
   831	void SyntaxTree::display(SyntaxTreeNode *n, int tabcount, FILE *fo){
   832		static int tab[200];	// is it enough?
   833		
   834		SyntaxTreeNode * node = n;
   835		if(node == NULL) return;
   836		
   837		if(node->type == NUM){
   838			fprintf(fo, "%-3d", node->value);
   839		}else{
   840			fprintf(fo, "%-3s", tokenToString(node->type));
   841		}
   842			
   843		if(node->left != NULL){
   844			tab[tabcount] = 1;
   845		}
   846		
   847		if(node->right != NULL){
   848			fprintf(fo, "---");
   849			this->display(node->right, tabcount + 1, fo);
   850		}
   851		
   852		if(node->left != NULL){
   853			fprintf(fo, "\n");
   854			for(int i=0;i<tabcount;i++){
   855				if(tab[i] == 1){
   856					fprintf(fo, "|%5s", "");
   857				}else{
   858					fprintf(fo, "%6s", "");
   859				}
   860			}
   861			fprintf(fo, "+-----");
   862			tab[tabcount] = 0;
   863			this->display(node->left, tabcount + 1, fo);
   864		}
   865		
   866	}
   867	
   868	void SyntaxTree::display(FILE *fo){
   869		if(fo == NULL){
   870			fo = stdout;
   871			printf("\nFILE* NULL, will write to STDOUT.\n\n");
   872		}
   873			
   874		fprintf(fo, "\n");
   875		this->display(root, 0, fo);
   876		fprintf(fo, "\n");
   877	}
   878	
   879	
   880	void SyntaxTree::setRootNode(TokenType t, int val){
   881		root = new SyntaxTreeNode(t, val);
   882	}
   883	void SyntaxTree::setRootNode(SyntaxTreeNode *n){
   884		if(n == NULL){
   885			root = new SyntaxTreeNode();
   886		}else{
   887			root = n;
   888		}
   889	}
   890	void SyntaxTree::setRootNode(){
   891		root = new SyntaxTreeNode();
   892	}
   893	
   894	
   895	void SyntaxTree::addLeft(TokenType t, int val){
   896		root->left = new SyntaxTreeNode(t, val);
   897	}
   898	void SyntaxTree::addLeft(SyntaxTree *n){
   899		if(n == NULL) return;
   900		root->left = n->getRootNode();
   901	}
   902	
   903	
   904	void SyntaxTree::addRight(TokenType t, int val){
   905		root->right = new SyntaxTreeNode(t, val);
   906	}
   907	void SyntaxTree::addRight(SyntaxTree *n){
   908		if(n == NULL) return;
   909		root->right = n->getRootNode();
   910	}
   911	
   912	
   913	void SyntaxTree::addChild3(TokenType t, int val){
   914		root->child3 = new SyntaxTreeNode(t, val);
   915	}
   916	void SyntaxTree::addChild3(SyntaxTree *n){
   917		if(n == NULL) return;
   918		root->child3 = n->getRootNode();
   919	}
   920	
   921	
   922	SyntaxTreeNode* SyntaxTree::getRootNode(){
   923		return root;
   924	}
   925	
   926	
   927	SyntaxTree* SyntaxTree::getLeft(){
   928		return new SyntaxTree(root->left);
   929	}
   930	
   931	SyntaxTree* SyntaxTree::getRight(){
   932		return new SyntaxTree(root->right);
   933	}
   934	
   935	
   936	SyntaxTree* SyntaxTree::getChild3(){
   937		return new SyntaxTree(root->child3);
   938	}
   939	
   940	/*==================================================================*/
   941	
   942	char* tokenToString(TokenType type){
   943		char *s = NULL;
   944		switch(type){
   945			case ID:
   946				s = "ID";
   947				break;
   948			case NUM:
   949				s = "NUM";
   950				break;
   951			case IF:
   952				s = "if";
   953				break;
   954			case THEN:
   955				s = "thn";
   956				break;
   957			case ELSE:
   958				s = "els";
   959				break;
   960			case WHILE:
   961				s = "whl";
   962				break;
   963			case DO:
   964				s = "do";
   965				break;
   966			case BEGIN:
   967				s = "blk";
   968				break;
   969			case END:
   970				s = "end";	// "end"
   971				break;
   972			case ASSIGN:
   973				s = "'='";
   974				break;
   975			case EQ:
   976				s = "==";
   977				break;
   978			case LT:
   979				s = "'<'";
   980				break;
   981			case GT:
   982				s = "'>'";
   983				break;
   984			case PLUS:
   985				s = "'+'";
   986				break;
   987			case MUL:
   988				s = "'*'";
   989				break;
   990			case OR:
   991				s = "'|'";
   992				break;
   993			case AND:
   994				s = "'&'";
   995				break;
   996			default:
   997				s = "undef";
   998		}
   999		return s;
  1000	}
  1001	
  1002	
  1003	
  1004	/**************************************************
  1005	* file: Parser.h
  1006	* date: 2006-04-12
  1007	* author: wuzuyang
  1008	* describe: none; parser
  1009	**************************************************/
  1010	
  1011	#include "common.h"
  1012	#include "Lexer.h"
  1013	#include "SyntaxTree.h"
  1014	
  1015	
  1016	class Parser{
  1017	private:
  1018		Lexer *lexer;
  1019		Token currentToken;
  1020		
  1021		SyntaxTree* Statement();
  1022		
  1023		SyntaxTree* Assign();
  1024		
  1025		SyntaxTree* Expression();
  1026			SyntaxTree* T();
  1027			SyntaxTree* F();
  1028	
  1029		SyntaxTree* Condition();
  1030		
  1031		SyntaxTree* Boolean();
  1032			SyntaxTree* T2();
  1033			SyntaxTree* F2();
  1034		SyntaxTree* While();
  1035		
  1036		SyntaxTree* Begin();
  1037	
  1038		SyntaxTree* Block();
  1039	
  1040		void printError(const char *error);
  1041	
  1042	public:
  1043		Parser(char* sourcefile);
  1044		~Parser();
  1045		
  1046		void printError();
  1047	
  1048		Token nextToken();
  1049		
  1050		SyntaxTree* parse();
  1051	};
  1052	
  1053	
  1054