temp.txt

一个编译器

  2109		}
  2110		
  2111		TRACE("out Boolean();");
  2112		return tree;
  2113	}
  2114	
  2115	
  2116	SyntaxTree* Parser::T2(){
  2117		SyntaxTree *temp = NULL;
  2118		SyntaxTree *tree = F2();
  2119	
  2120		if(tree == NULL){
  2121			return NULL;
  2122		}
  2123		
  2124		while(currentToken.type == AND){
  2125			temp = new SyntaxTree(AND);
  2126			temp->addLeft(tree);
  2127			tree = temp;
  2128			this->nextToken();
  2129			
  2130			temp = F2();
  2131			if(temp != NULL){
  2132				tree->addRight(temp);
  2133			}else{
  2134				this->printError("ERROR! behind AND;");
  2135				return NULL;
  2136			}
  2137		}
  2138		
  2139		return tree;
  2140	}
  2141	
  2142	
  2143	SyntaxTree* Parser::F2(){
  2144		SyntaxTree *temp = NULL;
  2145		SyntaxTree *tree = Expression();
  2146		
  2147		if(tree == NULL){
  2148			return NULL;
  2149		}
  2150		
  2151		switch(currentToken.type){
  2152			case LT:
  2153				temp = new SyntaxTree(LT);
  2154				break;
  2155			case GT:
  2156				temp = new SyntaxTree(GT);
  2157				break;
  2158			case EQ:
  2159				temp = new SyntaxTree(EQ);
  2160				break;
  2161			default :
  2162				break;
  2163		}
  2164		
  2165		if(temp != NULL){
  2166			this->nextToken();
  2167			temp->addLeft(tree);
  2168			tree = temp;
  2169			temp = Expression();
  2170			if(temp != NULL){
  2171				tree->addRight(temp);
  2172			}else{
  2173				this->printError("ERROR! Relation Operator needs Expression behind;");
  2174				return NULL;
  2175			}
  2176		}
  2177	
  2178		return tree;
  2179	}
  2180	
  2181	/*==================================================================*/
  2182	
  2183	SyntaxTree* Parser::While(){
  2184		TRACE("in While();");
  2185	
  2186		SyntaxTree *tree = new SyntaxTree(WHILE);
  2187		SyntaxTree *temp = Boolean();
  2188		
  2189		if(temp == NULL){
  2190			this->printError("ERROR! in While(); Condition NULL;");
  2191			return NULL;
  2192		}
  2193		tree->addLeft(temp);
  2194		
  2195		if(currentToken.type != DO){
  2196			this->printError("ERROR! in While(); token.type!=DO;");
  2197			return NULL;
  2198		}
  2199		this->nextToken();
  2200		temp = Statement();
  2201	
  2202		if(temp == NULL){
  2203			this->printError("ERROR! in While(); DO empty;");
  2204			return NULL;
  2205		}
  2206		tree->addRight(temp);
  2207		
  2208		TRACE("out While();");
  2209		return tree;
  2210	}
  2211	
  2212	
  2213	/*==================================================================*/
  2214	
  2215	SyntaxTree* Parser::Begin(){
  2216		return Block();
  2217	}
  2218	
  2219	/*
  2220		L = S(;S)* | <empsilon>
  2221	*/
  2222	SyntaxTree* Parser::Block(){
  2223		TRACE("in Block();");
  2224	
  2225		SyntaxTree *tree = Statement();
  2226		SyntaxTree *temp = new SyntaxTree(BEGIN);
  2227		
  2228		if(tree == NULL){
  2229			//this->printError("WARNNING! Don't accept empty block.");
  2230			return NULL;
  2231			/*
  2232			while(currentToken.type == SEMI){
  2233				this->nextToken();
  2234			}
  2235			return new SyntaxTree(BEGIN);
  2236			*/
  2237		}
  2238		temp->addLeft(tree);
  2239		tree = temp;
  2240		
  2241	//	temp = L2();
  2242	
  2243		while(currentToken.type == SEMI){
  2244			this->nextToken();
  2245		}
  2246		temp = Block();
  2247	
  2248		if(temp != NULL){	// it couldn't be
  2249			if(temp->getLeft() != NULL)
  2250				tree->addRight(temp);
  2251		}
  2252		
  2253		TRACE("out Block();");
  2254	
  2255		if(tree == NULL)
  2256			return NULL;
  2257		if(tree->getRight() == NULL)
  2258			return tree->getLeft();
  2259		else
  2260			return tree;
  2261	}
  2262	
  2263	
  2264	/*==================================================================*/
  2265	
  2266	
  2267	SyntaxTree* Parser::Condition(){
  2268		TRACE("in Condition();");
  2269		
  2270		SyntaxTree *tree = new SyntaxTree(IF);
  2271		SyntaxTree *temp = Boolean();
  2272		SyntaxTree *temp2 = NULL;
  2273		
  2274		if(temp == NULL){
  2275			this->printError("ERROR! if without a boolean statement.");
  2276			return NULL;
  2277		}
  2278		tree->addLeft(temp);
  2279		
  2280		if(currentToken.type != THEN){
  2281			this->printError("ERROR! if without then.");
  2282			return NULL;
  2283		}
  2284		this->nextToken();
  2285		temp = Statement();
  2286		
  2287		if(temp == NULL){
  2288			this->printError("ERROR! then without a statement.");
  2289			return NULL;
  2290		}
  2291		
  2292		temp2 = new SyntaxTree(THEN);
  2293		temp2->addLeft(temp);
  2294		
  2295		//temp2 = temp;
  2296		
  2297		this->nextToken();
  2298		if(currentToken.type == ELSE){
  2299			TRACE("ELSE");
  2300			this->nextToken();
  2301			//temp = new SyntaxTree(BEGIN);
  2302			//temp->addLeft(temp2);
  2303			//temp2 = temp;
  2304			
  2305			temp = Statement();
  2306			if(temp == NULL){
  2307				this->printError("ERROR! else without a statement.");
  2308				return NULL;
  2309			}
  2310			temp2->addRight(temp);
  2311		}
  2312		
  2313		tree->addRight(temp2);
  2314		
  2315		TRACE("out Condition();");
  2316		return tree;
  2317	}
  2318	
  2319	
  2320	
  2321	
  2322	/************************************************************
  2323	* file: SyntaxTree.cpp
  2324	* date: 2006-04-12
  2325	* author: wuzuyang
  2326	* describe: none; SyntaxTree
  2327	*************************************************************/
  2328	
  2329	#include <stdio.h>
  2330	#include <string.h>
  2331	#include "SyntaxTree.h"
  2332	
  2333	
  2334	char* tokenToString(TokenType type);
  2335	
  2336	/*======================================================================*/
  2337	
  2338	SyntaxTree::SyntaxTree(TokenType t, int val){
  2339		root = new SyntaxTreeNode(t, val);
  2340	}
  2341	SyntaxTree::SyntaxTree(SyntaxTreeNode *n){
  2342		setRootNode(n);
  2343	}
  2344	SyntaxTree::SyntaxTree(SyntaxTree *tree){
  2345		setRootNode(tree->getRootNode());
  2346	}
  2347	SyntaxTree::SyntaxTree(){
  2348		setRootNode();
  2349	}
  2350	
  2351	SyntaxTree::~SyntaxTree(){
  2352		// implement it later.
  2353	}
  2354	
  2355	/*====================================================================*/
  2356	
  2357	void SyntaxTree::display(SyntaxTreeNode *n, int tabcount, FILE *fo){
  2358		static int tab[200];	// is it enough?
  2359		
  2360		SyntaxTreeNode * node = n;
  2361		if(node == NULL) return;
  2362		
  2363		if(node->type == NUM){
  2364			fprintf(fo, "%-3d", node->value);
  2365		}else{
  2366			fprintf(fo, "%-3s", tokenToString(node->type));
  2367		}
  2368			
  2369		if(node->left != NULL){
  2370			tab[tabcount] = 1;
  2371		}
  2372		
  2373		if(node->right != NULL){
  2374			fprintf(fo, "---");
  2375			this->display(node->right, tabcount + 1, fo);
  2376		}
  2377		
  2378		if(node->left != NULL){
  2379			fprintf(fo, "\n");
  2380			for(int i=0;i<tabcount;i++){
  2381				if(tab[i] == 1){
  2382					fprintf(fo, "|%5s", "");
  2383				}else{
  2384					fprintf(fo, "%6s", "");
  2385				}
  2386			}
  2387			fprintf(fo, "+-----");
  2388			tab[tabcount] = 0;
  2389			this->display(node->left, tabcount + 1, fo);
  2390		}
  2391		
  2392	}
  2393	
  2394	void SyntaxTree::display(FILE *fo){
  2395		if(fo == NULL){
  2396			fo = stdout;
  2397			printf("\nFILE* NULL, will write to STDOUT.\n\n");
  2398		}
  2399			
  2400		fprintf(fo, "\n");
  2401		this->display(root, 0, fo);
  2402		fprintf(fo, "\n");
  2403	}
  2404	
  2405	
  2406	void SyntaxTree::setRootNode(TokenType t, int val){
  2407		root = new SyntaxTreeNode(t, val);
  2408	}
  2409	void SyntaxTree::setRootNode(SyntaxTreeNode *n){
  2410		if(n == NULL){
  2411			root = new SyntaxTreeNode();
  2412		}else{
  2413			root = n;
  2414		}
  2415	}
  2416	void SyntaxTree::setRootNode(){
  2417		root = new SyntaxTreeNode();
  2418	}
  2419	
  2420	
  2421	void SyntaxTree::addLeft(TokenType t, int val){
  2422		root->left = new SyntaxTreeNode(t, val);
  2423	}
  2424	void SyntaxTree::addLeft(SyntaxTree *n){
  2425		if(n == NULL) return;
  2426		root->left = n->getRootNode();
  2427	}
  2428	
  2429	
  2430	void SyntaxTree::addRight(TokenType t, int val){
  2431		root->right = new SyntaxTreeNode(t, val);
  2432	}
  2433	void SyntaxTree::addRight(SyntaxTree *n){
  2434		if(n == NULL) return;
  2435		root->right = n->getRootNode();
  2436	}
  2437	
  2438	
  2439	void SyntaxTree::addChild3(TokenType t, int val){
  2440		root->child3 = new SyntaxTreeNode(t, val);
  2441	}
  2442	void SyntaxTree::addChild3(SyntaxTree *n){
  2443		if(n == NULL) return;
  2444		root->child3 = n->getRootNode();
  2445	}
  2446	
  2447	
  2448	SyntaxTreeNode* SyntaxTree::getRootNode(){
  2449		return root;
  2450	}
  2451	
  2452	
  2453	SyntaxTree* SyntaxTree::getLeft(){
  2454		if(root->left == NULL)
  2455			return NULL;
  2456		else
  2457			return new SyntaxTree(root->left);
  2458	}
  2459	
  2460	SyntaxTree* SyntaxTree::getRight(){
  2461		if(root->right == NULL)
  2462			return NULL;
  2463		else
  2464			return new SyntaxTree(root->right);
  2465	}
  2466	
  2467	
  2468	SyntaxTree* SyntaxTree::getChild3(){
  2469		if(root->child3 == NULL)
  2470			return NULL;
  2471		else
  2472			return new SyntaxTree(root->child3);
  2473	}
  2474	
  2475	/*==================================================================*/
  2476	
  2477	char* tokenToString(TokenType type){
  2478		char *s = NULL;
  2479		switch(type){
  2480			case ID:
  2481				s = "ID";
  2482				break;
  2483			case NUM:
  2484				s = "NUM";
  2485				break;
  2486			case IF:
  2487				s = "if";
  2488				break;
  2489			case THEN:
  2490				s = "thn";
  2491				break;
  2492			case ELSE:
  2493				s = "els";
  2494				break;
  2495			case WHILE:
  2496				s = "whl";
  2497				break;
  2498			case DO:
  2499				s = "do";
  2500				break;
  2501			case BEGIN:
  2502				s = "blk";
  2503				break;
  2504			case END:
  2505				s = "end";	// "end"
  2506				break;
  2507			case ASSIGN:
  2508				s = "'='";
  2509				break;
  2510			case EQ:
  2511				s = "==";
  2512				break;
  2513			case LT:
  2514				s = "'<'";
  2515				break;
  2516			case GT:
  2517				s = "'>'";
  2518				break;
  2519			case PLUS:
  2520				s = "'+'";
  2521				break;
  2522			case MUL:
  2523				s = "'*'";
  2524				break;
  2525			case OR:
  2526				s = "'|'";
  2527				break;
  2528			case AND:
  2529				s = "'&'";
  2530				break;
  2531			default:
  2532				s = "undef";
  2533		}
  2534		return s;
  2535	}
  2536	
  2537	
  2538	
  2539	/************************************************************
  2540	* file: SyntaxTreeNode.cpp
  2541	* date: 2006-04-12
  2542	* author: wuzuyang
  2543	* describe: none; SyntaxTreeNode
  2544	*************************************************************/
  2545	
  2546	#include "SyntaxTreeNode.h"
  2547	
  2548	
  2549	SyntaxTreeNode::SyntaxTreeNode(){
  2550		type = ERROR;
  2551		value = 0;
  2552		left = right = child3 = NULL;
  2553	}
  2554	SyntaxTreeNode::SyntaxTreeNode(TokenType t, int val){
  2555		type = t;
  2556		value = val;
  2557		left = right = child3 = NULL;
  2558	}
  2559	
  2560	SyntaxTreeNode::~SyntaxTreeNode(){
  2561	}
  2562	
  2563	/*===================================================================*/
  2564	
  2565	void SyntaxTreeNode::setType(TokenType t){
  2566		type = t;
  2567	}
  2568	
  2569	TokenType SyntaxTreeNode::getType(){
  2570		return type;
  2571	}
  2572	
  2573	void SyntaxTreeNode::setValue(int val){
  2574		value = val;
  2575	}
  2576	
  2577	int SyntaxTreeNode::getValue(){
  2578		return value;
  2579	}
  2580	
  2581	
  2582	void SyntaxTreeNode::addLeft(TokenType t, int val){
  2583		left = new SyntaxTreeNode(t, val);
  2584	}
  2585	void SyntaxTreeNode::addLeft(SyntaxTreeNode *n){
  2586		left = n;
  2587	}
  2588	
  2589	
  2590	void SyntaxTreeNode::addRight(TokenType t, int val){
  2591		right = new SyntaxTreeNode(t, val);
  2592	}
  2593	void SyntaxTreeNode::addRight(SyntaxTreeNode *n){
  2594		right = n;
  2595	}
  2596	
  2597	
  2598	void SyntaxTreeNode::addChild3(TokenType t, int val){
  2599		child3 = new SyntaxTreeNode(t, val);
  2600	}
  2601	void SyntaxTreeNode::addChild3(SyntaxTreeNode *n){
  2602		child3 = n;
  2603	}
  2604	
  2605	
  2606	SyntaxTreeNode* SyntaxTreeNode::getLeft(){
  2607		return left;
  2608	}
  2609	
  2610	SyntaxTreeNode* SyntaxTreeNode::getRight(){
  2611		return right;
  2612	}
  2613	
  2614	SyntaxTreeNode* SyntaxTreeNode::getChild3(){
  2615		return child3;
  2616	}
  2617	
  2618	
  2619	
  2620	
  2621	#include <stdio.h>
  2622	#include <unistd.h>
  2623	#include <sys/stat.h>
  2624	#include <fcntl.h>
  2625	
  2626	int main(){
  2627		int fd = open("myfile.txt", O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR);
  2628		if(fd != -1){
  2629			if(dup2(fd, STDOUT_FILENO) == -1){
  2630				printf("can't close file!\n");
  2631				return 1;
  2632			}
  2633	
  2634			printf