stack.c

一个程序拿来对一个C文件做基本的语法检查

#include <stdio.h>
#include <stdlib.h>
#include "Stack.h"

NODE stack = {NONE, 0, NULL};
NODE *pTop = &stack;

static void RearrangeErrorReport(void);
static BOOL isTokenMatch(TOKEN, TOKEN);
static NODE* popNode();
static void pushNode(NODE*);

static void RearrangeErrorReport(void)
{
	NODE *pPop, *pRemove;
	
	if(NULL == stack.next)
		return;
	else{
		pPop = popNode();
		if(NULL == stack.next)
			pushNode(pPop);
		else if(TRUE == isTokenMatch(pTop->token, pPop->token)){
			free(pPop);
			pPop = popNode();
			free(pPop);
			RearrangeErrorReport();
		}
		else if(TRUE == isTokenMatch(stack.next->token, pPop->token)){
			pRemove = stack.next;
			stack.next = pRemove->next;
			free(pRemove);
			free(pPop);
			RearrangeErrorReport();
		}
		else{
			RearrangeErrorReport();
			pushNode(pPop);
		}
	}
}

static BOOL isTokenMatch(TOKEN FirstToken, TOKEN SecondToken)
{
    switch(FirstToken){
        case LeftCircleBracket:
            return SecondToken == RightCircleBracket;
        case LeftSquareBracket:
            return SecondToken == RightSquareBracket;
        case LeftFlowerBracket:
            return SecondToken == RightFlowerBracket;
        case LeftCommentLine:
            return SecondToken == RightCommentLine;
        case DoubleSlashComment:
            return SecondToken == Newline;
        case SingleQuotation:
        	return SecondToken == SingleQuotation;
        case DoubleQuotation:
        	return SecondToken == DoubleQuotation;
        default:
            return FALSE;
    }
}

static NODE* popNode()
{
    NODE *pTmpNode;

    if(pTop == &stack)
        return NULL;
	else
		pTmpNode = &stack;
    while(pTop != pTmpNode->next)
        pTmpNode = pTmpNode->next;

    pTop = pTmpNode;
    pTmpNode = pTop->next;
    pTop->next = NULL;
	stack.line--;

	return pTmpNode;
}

static void pushNode(NODE* pNewNode)
{
    pTop->next = pNewNode;
    pTop = pNewNode;
	stack.line++;
}

void PrintError(void)
{
	NODE *pTmp, *pRemove;
	UINT32 OldNodeNb;
	
	if(stack.next == NULL)
		printf("The file pass parse successfully\n");
	else{
		do{
			OldNodeNb = stack.line;
			RearrangeErrorReport();
		} while(OldNodeNb != stack.line);
		for( pRemove = stack.next ; pRemove ; pRemove = pTmp ){
			printf("Line %d: There is no matched symbol for ", pRemove->line);
			switch(pRemove->token){
				case LeftCircleBracket:
					printf("\'(\'\n");
					break;
    			case RightCircleBracket:
					printf("\')\'\n");
					break;
    			case LeftSquareBracket:
					printf("\'[\'\n");
					break;
    			case RightSquareBracket:
					printf("\']\'\n");
					break;
    			case LeftFlowerBracket:
					printf("\'{\'\n");
					break;
    			case RightFlowerBracket:
					printf("\'}\'\n");
					break;
    			case LeftCommentLine:
					printf("\'/*\'\n");
					break;
    			case RightCommentLine:
					printf("\'*/\'\n");
					break;
    			case DoubleSlashComment:
					printf("\'//\'\n");
					break;
    			case Newline:
					printf("\'\\n\'\n");
					break;
    			case SingleQuotation:
 					printf("\'\'\'\n");
					break;
   				case DoubleQuotation:
					printf("\'\"\'\n");
					break;
			}
			pTmp = pRemove->next;
			free(pRemove);
		}
	}
}

void push(TOKEN token, UINT32 line)
{
    NODE *pNewNode = (NODE*)malloc(sizeof(NODE));

    pNewNode->token = token;
    pNewNode->line = line;
    pNewNode->next = NULL;
	pushNode(pNewNode);
}

TOKEN pop()
{
	NODE *pTmpNode = popNode();
	TOKEN token;

	if(NULL == pTmpNode)
		return NONE;
	else{
		token = pTmpNode->token;
		free(pTmpNode);
		return token;
	}
}

BOOL isTokenMatchTop(TOKEN token)
{
	if(NULL == stack.next)
		return FALSE;
	else
		return isTokenMatch(pTop->token, token);
}


typedef enum {
	eNULL,			// Normal state
	eSlashFound,	// Find a slash '/'
	eStarFound,		// Find a star '*'
	eBackSlashFound
} ePARSESTATE;

TOKEN GetNextToken(BYTE **pSrc, BYTE *pEnd, TOKEN PreferToken)
{
	static ePARSESTATE eParseState = eNULL;
	TOKEN ResultToken = NONE;
		
	for(  ; *pSrc < pEnd ; (*pSrc)++ ){
		switch(**pSrc){
			case cBACKSLASH_SYMBOL:
				if(eBackSlashFound == eParseState)
					eParseState = eNULL;
				else
					eParseState = eBackSlashFound;
				break;
 			case cSLASH_SYMBOL:
 				switch(eParseState){
 					case eNULL:
 						eParseState = eSlashFound;
 						break;
 					case eSlashFound:
 						eParseState = eNULL;
 						ResultToken = DoubleSlashComment;
 						break;
 					case eStarFound:
 						eParseState = eNULL;
 						ResultToken = RightCommentLine;
 						break;
 				}
 				break;
 			case cSTAR_SYMBOL:
 				switch(eParseState){
 					case eNULL:
 						eParseState = eStarFound;
 						break;
 					case eSlashFound:
 						eParseState = eNULL;
 						ResultToken = LeftCommentLine;
 						break;
 				}
 				break;
 			case cNEWLINE_SYMBOL:
 				eParseState = eNULL;
 				ResultToken = Newline;
 				break;
 			case cLEFT_CIRCLEBRACKET:
 				eParseState = eNULL;
 				ResultToken = LeftCircleBracket;
 				break;
 			case cRIGHT_CIRCLEBRACKET:
 				eParseState = eNULL;
 				ResultToken = RightCircleBracket;
 				break;
 			case cLEFT_SQUAREBRACKET:
 				eParseState = eNULL;
 				ResultToken = LeftSquareBracket;
 				break;
 			case cRIGHT_SQUAREBRACKET:
 				eParseState = eNULL;
 				ResultToken = RightSquareBracket;
 				break;
 			case cLEFT_FLOWERBRACKET:
 				eParseState = eNULL;
 				ResultToken = LeftFlowerBracket;
 				break;
 			case cRIGHT_FLOWERBRACKET:
 				eParseState = eNULL;
 				ResultToken = RightFlowerBracket;
 				break;
 			case cSINGLE_QUOTATION:
 				if(eBackSlashFound != eParseState)
 					ResultToken = SingleQuotation;
 				eParseState = eNULL;
 				break;
 			case cDOUBLE_QUOTATION:
 				if(eBackSlashFound != eParseState)
 					ResultToken = DoubleQuotation;
 				eParseState = eNULL;
 				break;
 			default:
 				eParseState = eNULL;
 				break;
 		}
 
 		if((NONE != ResultToken) &&
 		   ((NONE == PreferToken) || 
 		    (Newline == ResultToken) ||
 		    (PreferToken == ResultToken))){
 			(*pSrc)++;
 			return ResultToken;
 		}
 	}
 	
 	return NONE;
 }