mycompiler.cpp

这可是我的倾情制作

		case 63:/*Deal with beginning of '(' including: ( */
			MoveToNextChar();
			lexbegin = lexforward;
			return LBRAKET;
		case 64:/*Deal with beginning of ')' including: ) */
			MoveToNextChar();
			lexbegin = lexforward;
			return RBRAKET;
		case 65:/*Deal with beginning of '[' including: [ */
			MoveToNextChar();
			lexbegin = lexforward;
			return LSBRACE;
		case 66:/*Deal with beginning of ']' including: ] */
			MoveToNextChar();
			lexbegin = lexforward;
			return RSBRACE;
		case 67:/*Deal with beginning of '{' including: } */
			MoveToNextChar();
			lexbegin = lexforward;
			return LBRACE;
		case 68:/*Deal with beginning of '}' including: } */
			MoveToNextChar();
			lexbegin = lexforward;
			return RBRACE;
		case 69:/*Deal with beginning of '#' including: # */
			MoveToNextChar();
			lexbegin = lexforward;
			return SHARP;
		case 70:/*Deal with beginning of '%' including: % , %= */
			MoveToNextChar();
			lexbegin = lexforward;
			if(CurChar != '=')
				return MOD;
			MoveToNextChar();
			lexbegin = lexforward;
			return MODQ;
		case 73:/*Deal with beginning of '"' including: constant character string and escape char*/
			MoveToNextChar();
			lexbegin = lexforward;
			Counter = 0;
			while(CurChar != '"' && Counter < SIZEOFCHARBUFFER&&CurChar !='\n')
			{
				if(CurChar == '\\')
				{
				MoveToNextChar();
				switch(CurChar)
				{
					case '\\':/*Deal with escape */
						LexBuffer[Counter] = '\\';
						MoveToNextChar();
						break;
					case 'x':
						MoveToNextChar();
						if(isxdigit(CurChar))/*After \x there is maybe one or two hex nums */
						{
							LexBuffer[Counter] = CurChar;
							MoveToNextChar();
							if(isxdigit(CurChar)) /*After \x there is two hex nums*/
							{
								LexBuffer[Counter + 1] = CurChar;
								LexBuffer[Counter + 2] = EOS;
								LexBuffer[Counter] = strtol (LexBuffer+Counter,&endptr,16);
								MoveToNextChar();
							}
							else		/*After \x there is only one hex nums */
							{
								LexBuffer[Counter + 1] = EOS;
								LexBuffer[Counter] = strtol (LexBuffer+Counter,&endptr,16);
							}
						}
						else 	/*After \x there is no hex nums left */
						{
							LexBuffer[Counter] = CurChar;
							MoveToNextChar();
						}
						break;
					case 'f':/* char:/f */
						LexBuffer[Counter] = 0x0c;
						MoveToNextChar();
						break;
					case 'r':/* char:/r */
						LexBuffer[Counter] = 0x0d;
						MoveToNextChar();
						break;
					case 't':/* char:/t */
						LexBuffer[Counter] = 0x09;
						MoveToNextChar();
						break;
					case 'n':/* char:/n */
						LexBuffer[Counter] = 0x0a;
						MoveToNextChar();
						break;
					case '\'':/* char:/' */
						LexBuffer[Counter] = 0x27;
						MoveToNextChar();
						break;
					case '"':/* char:/" */
						LexBuffer[Counter] = 0x22;
						MoveToNextChar();
						break;
					default :/* char:/any other key excluding chars above */
						if(isdigit(CurChar)&&CurChar!='9'&&CurChar!='8')  /*Deal with after \ is Oct num*/
						{
							LexBuffer[Counter]=CurChar;
							MoveToNextChar();
							if(isdigit(CurChar)&&CurChar!='9'&&CurChar!='8')
							{
								LexBuffer[Counter+1]=CurChar;
								MoveToNextChar();
								if(isdigit(CurChar)&&CurChar!='9'&&CurChar!='8') /*there is 3 Oct Nums after / */
								{
									LexBuffer[Counter+2]=CurChar;
									LexBuffer[Counter+3]=EOS;
									MidIntUse = strtol(LexBuffer + Counter,&endptr,8);
									if(MidIntUse>127||
									MidIntUse<-128)
										error("Constant is too large");  /*after / the Oct Num is larger then maxium of char (+127)*/
									else LexBuffer[Counter] = MidIntUse;
									MoveToNextChar();
								}
								else /*after / there is two Oct nums*/
								{
									LexBuffer[Counter+2]=EOS;
									LexBuffer[Counter]=strtol(LexBuffer + Counter,&endptr,8);
								}
							}
							else  /*after / there is only one Oct num*/
							{
								LexBuffer[Counter]=CurChar - '0';
							}
						}/*After / is nonnum*/
						else{
						LexBuffer[Counter] = CurChar;
						MoveToNextChar();
						}
						break;

				}/*switch(CurChar)*/
				}/*if then*/
				else
				{
					LexBuffer[Counter] = CurChar;
					MoveToNextChar();
				}
				Counter ++;
			}/*end while (CurChar != '"')*/
			if(Counter == SIZEOFCHARBUFFER)
			{
				error("Constant String is larger then SIZEOFCHARBUFFER(32)");
				MoveToNextChar();
				lexbegin = lexforward;
				break;
			}
			if(CurChar == '\n')
			{
				error("Constant String should be finished in a line");
				MoveToNextChar();
				lexbegin = lexforward;
				break;
			}
				temptr = (char *)malloc(sizeof(char)*Counter);
			strncpy(temptr,LexBuffer,Counter);
			temptr[Counter -1]=EOS;
			/*Just put the string into SymbolTable*/
			TempSymbol = InsertIntoSymbolTable(::CurSymbolTable,temptr,STRINGS);
			CurSymbol = TempSymbol;
			MoveToNextChar();
			lexbegin = lexforward;
			return CurSymbol->TokenNum;
		case 78:/*Deal with beginning of '\'' including: one char included */
			MoveToNextChar();
			lexbegin = lexforward;
			Counter = 0;

				if(CurChar == '\\')
				{
				MoveToNextChar();
				switch(CurChar)
				{
					case '\\':/*Deal with escape */
						LexBuffer[Counter] = '\\';
						MoveToNextChar();
						break;
					case 'x':
						MoveToNextChar();
						if(isxdigit(CurChar))/*After \x there is maybe one or two hex nums */
						{
							LexBuffer[Counter] = CurChar;
							MoveToNextChar();
							if(isxdigit(CurChar)) /*After \x there is two hex nums*/
							{
								LexBuffer[Counter + 1] = CurChar;
								LexBuffer[Counter + 2] = EOS;
								LexBuffer[Counter] = strtol (LexBuffer+Counter,&endptr,16);
								MoveToNextChar();
							}
							else		/*After \x there is only one hex nums */
							{
								LexBuffer[Counter + 1] = EOS;
								LexBuffer[Counter] = strtol (LexBuffer+Counter,&endptr,16);
							}
						}
						else 	/*After \x there is no hex nums left */
						{
							LexBuffer[Counter] = CurChar;
							MoveToNextChar();
						}
						break;
					case 'f':/* char:/f */
						LexBuffer[Counter] = 0x0c;
						MoveToNextChar();
						break;
					case 'r':/* char:/r */
						LexBuffer[Counter] = 0x0d;
						MoveToNextChar();
						break;
					case 't':/* char:/t */
						LexBuffer[Counter] = 0x09;
						MoveToNextChar();
						break;
					case 'n':/* char:/n */
						LexBuffer[Counter] = 0x0a;
						MoveToNextChar();
						break;
					case '\'':/* char:/' */
						LexBuffer[Counter] = 0x27;
						MoveToNextChar();
						break;
					case '"':/* char:/" */
						LexBuffer[Counter] = 0x22;
						MoveToNextChar();
						break;
					default :/* char:/any other key excluding chars above */
						if(isdigit(CurChar)&&CurChar!='9'&&CurChar!='8')  /*Deal with after \ is Oct num*/
						{
							LexBuffer[Counter]=CurChar;
							MoveToNextChar();
							if(isdigit(CurChar)&&CurChar!='9'&&CurChar!='8')
							{
								LexBuffer[Counter+1]=CurChar;
								MoveToNextChar();
								if(isdigit(CurChar)&&CurChar!='9'&&CurChar!='8') /*there is 3 Oct Nums after / */
								{
									LexBuffer[Counter+2]=CurChar;
									LexBuffer[Counter+3]=EOS;
									MidIntUse = strtol(LexBuffer + Counter,&endptr,8);
									if(MidIntUse>127||MidIntUse<-128)
										error("Constant is too large");  /*after / the Oct Num is larger then maxium of char (+127)*/
									else LexBuffer[Counter] = MidIntUse;
									MoveToNextChar();
								}
								else /*after / there is two Oct nums*/
								{
									LexBuffer[Counter+2]=EOS;
									LexBuffer[Counter]=(char)strtol(LexBuffer + Counter,&endptr,8);
								}
							}
							else  /*after / there is only one Oct num*/
							{
								LexBuffer[Counter]=CurChar - '0';
							}
						}/*After / is nonnum*/
						else{
						LexBuffer[Counter] = CurChar;
						MoveToNextChar();
						}
						break;

				}/*switch(CurChar)*/
				}/*if then*/
				else
				{
					LexBuffer[Counter] = CurChar;
					MoveToNextChar();
				}
			token1 = LexBuffer[Counter];
			if(CurChar != '\'')
			{
				error("Constant Char should be One Byte!");
				state = 1;
				break;
			}
			MoveToNextChar();
			lexbegin = lexforward;
			return CHARONE;
		case 80:/*Deal with syntax variable*/
			do{
			MoveToNextChar();
			}while(isdigit(CurChar)||isalpha(CurChar)||CurChar == '_');
			/*Just move the last @ into buffer*/
			MoveToNextChar();

			GetIntoLexBufferFromInputBuffer();
			lexbegin = lexforward;
			/*Determine whether it is key words*/
			/*if it is , we just return the key words TokenNum */
			/*if it is not , we insert it into SymbolTable return ID tokennum*/
			TempSymbol = LookWordsUpSymbolTable(::G_SymbolTable,LexBuffer);
			if(TempSymbol == NULL)
			{
				TempSymbol = InsertIntoSymbolTable(::G_SymbolTable,LexBuffer,SyntaxCounter+BASEOFSYN);
				 TempSyntaxVar = (pSyntaxVarType) malloc(sizeof(SyntaxVarType));
				 TempSyntaxVar->ProductHead = NULL;
				 TempSyntaxVar->Length = 0;
				 TempSyntaxVar->BasicInfo = TempSymbol;
				 SyntaxCounter ++;
				 AddSyntaxVar(TempSyntaxVar);
				
			}
			CurSymbol = TempSymbol;
			return CurSymbol->TokenNum;
		}/*switch(state)*/
	}/*end while*/

}/*End int lexan func*/

/*Generate Hash Number to assign SymbolTable index*/
int hashpjw(char * inString)
{
	char *p;
	unsigned long h =0,g;
	for( p = inString; *p!=EOS;p++)
	{
		h = (h <<4)+(*p);
		if(g = h&0xf0000000)
		{
			h = h ^ (g>>24);
			h = h ^ g;
		}
	}
	return h % SIZEOFSYMTABLE;
}/*hashpjw*/

/*to initializejSymbolTable:put key words into it*/
void InitializeGlobalSymbolTable()
{
//	int counter;
//	pSymbolType tempSymbol;
	if(G_SymbolTable != NULL)
		::DestructSymbolTable(G_SymbolTable);
	
	G_SymbolTable = ::ConstructSymbolTable(NULL);

	InsertIntoSymbolTable( G_SymbolTable , "int" , INT     );
	InsertIntoSymbolTable( G_SymbolTable , "double" , DOUBLE  );
	InsertIntoSymbolTable( G_SymbolTable , "struct" , STRUCT  );
	InsertIntoSymbolTable( G_SymbolTable , "break" , BREAK   );
	InsertIntoSymbolTable( G_SymbolTable , "else" , ELSE    );
	InsertIntoSymbolTable( G_SymbolTable , "long" , LONG    );
	InsertIntoSymbolTable( G_SymbolTable , "switch" , SWITCH  );
	InsertIntoSymbolTable( G_SymbolTable , "case" , CASE    );
	InsertIntoSymbolTable( G_SymbolTable , "enum" , ENUM    );
	InsertIntoSymbolTable( G_SymbolTable , "typedef" , TYPEDEF );
	InsertIntoSymbolTable( G_SymbolTable , "char" , CHAR    );
	InsertIntoSymbolTable( G_SymbolTable , "return" , RETURN  );
	InsertIntoSymbolTable( G_SymbolTable , "extern" , EXTERN  );
	InsertIntoSymbolTable( G_SymbolTable , "union" , UNION   );
	InsertIntoSymbolTable( G_SymbolTable , "float" , FLOAT   );
	InsertIntoSymbolTable( G_SymbolTable , "short" , SHORT   );
	InsertIntoSymbolTable( G_SymbolTable , "unsigned" , UNSIGNED);
	InsertIntoSymbolTable( G_SymbolTable , "continue" , CONTINUE);
	InsertIntoSymbolTable( G_SymbolTable , "for" , FOR     );
	InsertIntoSymbolTable( G_SymbolTable , "signed" , SIGNED  );
	InsertIntoSymbolTable( G_SymbolTable , "void" , VOID    );
	InsertIntoSymbolTable( G_SymbolTable , "default" , DEFAULT );
	InsertIntoSymbolTable( G_SymbolTable , "goto" , GOTO    );
	InsertIntoSymbolTable( G_SymbolTable , "sizeof" , SIZEOF  );
	InsertIntoSymbolTable( G_SymbolTable , "do" , DO      );
	InsertIntoSymbolTable( G_SymbolTable , "if" , IF      );
	InsertIntoSymbolTable( G_SymbolTable , "while" , WHILE   );
	/*InsertIntoSymbolTable( G_SymbolTable , "main" , FMAIN   );*/ /*Main has been removed from key word list for C(99) */
	InsertIntoSymbolTable( G_SymbolTable , "define" , CDEF    );
	InsertIntoSymbolTable( G_SymbolTable , "include" , CINC    );

}/*InitializeSymbolTable*/

/*Construct a Symbol Table dynamically and return the pointer back*/
pSymbolTableType ConstructSymbolTable(pSymbolTableType FatherPoint_in)
{
	int i;
	pSymbolTableType result;