parser.cpp.bak

仅作参考。 测试环境：WinXP + VC6.0+sp6 Redhat Linux AS 3 + Gcc3.x.x Solaris 10 + Gcc3

#include "../include/parser.h"
#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include<stdlib.h> 


namespace TVParser
{

	AlgorithmParser::AlgorithmParser()
	{

	}
	AlgorithmParser::~AlgorithmParser()
	{
	
	
	}
	char* AlgorithmParser::Compute(char* inputTokens)
	{
		if(*inputTokens)
		{
			InfiToPostfix(inputTokens);
			return Calculate("");
		}
		else
		{
			return NULL;
		}
	}
	char* AlgorithmParser::InfiToPostfix(char* infixTokens)
	{	
		char* pValue = infixTokens;
		char* pStringHdr = NULL;
		bool isStart = true;
		char aOperator[2];
		while(*pValue != '\0')
		{
			if(*pValue == ' ')
			{
				if(pStringHdr != NULL && !isStart)
				{
					pStringHdr = Substring(pStringHdr,0,pValue - pStringHdr);
					if(strcmp(pStringHdr,""))
					{
						_StringList.Enqueue(pStringHdr);
					}
					free(pStringHdr);	
				}
				else if (isStart && pStringHdr != NULL)
				{

				}
				pValue ++;
				pStringHdr = pValue;
				continue;
			}
			if(Isoperator(*pValue))
			{
				aOperator[0] = *pValue;
				aOperator[1] = '\0';
				if (IsSign(*pValue, pValue - infixTokens , infixTokens))
                {
						if(*pValue == '+')
						{
							aOperator[0] = '$';
						}
						else if(*pValue == '-')
						{
							aOperator[0] = '@';
						}
                }	
				if((*pValue != '(') && (pValue - infixTokens > 0))
				{
					pStringHdr = Substring(pStringHdr,0,pValue - pStringHdr);
					if(strcmp(pStringHdr,""))
					{
						_StringList.Enqueue(pStringHdr);
					}
					free(pStringHdr);					
				}
				GetOutput(aOperator);
				aOperator[0] = '\0';
				isStart = true;				
				pValue ++;
				pStringHdr = pValue;
			}
			else
			{
				if(isStart)
				{				    
					pStringHdr = pValue;
					isStart = false;
				}
				pValue ++;				
			}
			
		}
		pStringHdr = Substring(pStringHdr,0,pValue - pStringHdr);
		if(strcmp(pStringHdr,""))
		{
			_StringList.Enqueue(pStringHdr);
		}
		free(pStringHdr);
		pStringHdr = _Stack.Pop();
		while(pStringHdr != NULL)
		{
			_StringList.Enqueue(pStringHdr);
			pStringHdr = _Stack.Pop();
		}
		return NULL;
	}
	char* AlgorithmParser::Calculate(char* postfixTokens)
	{
		char* curString = _StringList.Dequeue();
		char* leftOperand = NULL;
		char* rightOperand = NULL;
		char* oper = NULL;
		char op[2];
		while(curString != NULL)
		{
			if(GetperatorPriority(curString) == 0)
			{			
				_Stack.Push(curString);
			}
			else
			{	
				if(IsSingleOperator(curString))
				{
					rightOperand = _Stack.Pop();
                    op[0] = GetSingleOpertor(curString);
					op[1] = '\0';
                    Compute("0", op, rightOperand);
					op[0] = '\0';
				}
				else
				{
					rightOperand = _Stack.Pop();
					leftOperand = _Stack.Pop();
					Compute(leftOperand,curString,rightOperand);
				}
			}
			curString = _StringList.Dequeue();
		}
		return _Stack.Pop();
	}
	char* AlgorithmParser::GetUnsignedOperand(char* operand)
	{
		char* pOperand = operand;
		bool issigned = IsSigned(pOperand);
		if(!issigned)
		{
			return operand;
		}
		char* rightOperand = operand;
		int pos = GetLastSign(pOperand) ;
		if(pos >0)
		{
			rightOperand = pOperand + pos ;
		}
		while (pos >0)
        {
			char sign[2];	 
			sign[0]= pOperand[pos -1];
			sign[1] = '\0';
            Compute("0", sign, rightOperand);
			rightOperand = _Stack.Pop();
			pos --;
        }
		return rightOperand;

	}
	int AlgorithmParser::GetLastSign(char* pOperand)
	{
		char* ptr = pOperand;
		while((*ptr == '+' || *ptr == '-') && (*ptr != '\0') )
		{
			ptr ++;
		}
		return ptr - pOperand;

	}
	bool AlgorithmParser::IsSigned(char* pOperand)
	{
		char* pString = pOperand;
		while(*pString != '\0')
		{
			if((*pString == '+' || *pString == '-') && ((pString - pOperand)==0))
			{
				return true;
			}
			if(*pString == '+' || *pString == '-')
			{
				if(*(pString + 1) == ' ')
				{
					char* pStringNext = pString + 1;
					while(*pStringNext != '\0')
					{
						if(*pStringNext != ' ')
						{
							if(*pStringNext != '+' || *pStringNext != '-')
							{
								return true;
							}
						}
						pStringNext ++;
					}
					return false;
				}
				else if(*(pString + 1) == '\0')
				{
					return false;
				}
				else if(*(pString + 1) == '+' || *(pString + 1) == '-')
				{
					return true;
				}
			}
			pString ++;
		}
		return false;
	}
	char* AlgorithmParser::Compute(char* leftoperand,char* op,char* rightoperand)
	{
		char result[255];
		double fleft =  atof(leftoperand);
		double fright = atof(rightoperand);
		double f ;
		if(!strcmp(op,"*"))
		{
			f = fleft * fright;

		}
		else if(!strcmp(op,"/"))
		{
			f = fleft / fright;

		}
		else if(!strcmp(op,"+"))
		{
			f = fleft + fright;

		}
		else if(!strcmp(op,"-"))
		{
			f = fleft - fright;

		}
		sprintf(result,"%f",f);
		result[strlen(result)] = '\0';
		_Stack.Push(result);
		return NULL;
	}
	char* AlgorithmParser::GetNetToken(int* pos, char* tokens, int* isOperator)
	{
		return NULL;
	}
	char* AlgorithmParser::GetOutput(char* aOperator)
	{
		char* popString = NULL;
		if(aOperator[0] == ')')
		{
			popString = _Stack.Pop();
            while (popString != NULL && strcmp(popString,"("))
            {
                _StringList.Enqueue(popString);
                popString =_Stack.Pop();
            }
			return NULL;
		}
		else if (aOperator[0] == '@' || aOperator[0] == '$')
        {
            _Stack.Push(aOperator);
			return NULL;
        }
		else
		{
			popString = _Stack.Pop();
			if(popString == NULL)
			{
				_Stack.Push(aOperator);
				return NULL;
			}
			int popPriority = GetperatorPriority(popString);
			int inOperPriority = GetperatorPriority(aOperator);
			if(popPriority >= inOperPriority)
			{
				while(popString != NULL && (popPriority >= inOperPriority) && strcmp(popString,"("))
				{
					_StringList.Enqueue(popString);
					popString = _Stack.Pop();
					popPriority = GetperatorPriority(popString);
					inOperPriority = GetperatorPriority(aOperator);
				}
				if(popString != NULL)
				{
					_Stack.Push(popString);
				}
				_Stack.Push(aOperator);
				return NULL;
			}
			else
			{
				_Stack.Push(popString);
				_Stack.Push(aOperator);
				return aOperator;
			}
		}
		
	}
	char AlgorithmParser::GetSingleOpertor(char* op)
	{
		if (!strcmp(op,"@"))
		{
			return '-';
		}
		else if(!strcmp(op,"$"))
        {
			return '+';
		}
		return 0;
	}
	bool AlgorithmParser::IsSign(char token,int pos,char* tokens)
	{
		if (token != '+' && token != '-')
        {
            return false;
        }
        else
        {
            if (pos == 0) 
			{
				return true;
			}
            char pretoken = tokens[pos -1];
			int apos = pos -1;
			while(pretoken == ' ' && pos > 0)
			{
				pretoken = tokens[apos -1];
				apos --;
			}
			if(apos < 0 || pretoken == ' ')
			{
				return true;
			}
            else if ( IsLetterOrDigit(pretoken)|| pretoken == ')')
            {
                return false;
            }
            else if(pretoken == '(' || IsNonSignOperator(pretoken))
            {
                return true;
            }
        }
        return true;
	}
	bool AlgorithmParser::IsLetterOrDigit(char token)
	{
		if((token >= 'a' && token <= 'z') || (token >= 'A' && token <= 'Z'))
		{
			return true;
		}
		else if((token >= '0' && token <= '9') || (token =='.'))
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	bool AlgorithmParser::Isoperator(char token)
	{
		if(token == '(' || token == ')' || token == '+' || token == '-' || token == '*' || token == '/'  || token == '@' || token == '$')
		{
			return true;
		}
		return false;
	}
	bool AlgorithmParser::IsNonSignOperator(char token)
	{
		if(token == '*' || token == '/' || token == '+' || token == '-')
		{
			return true;
		}
		return false;
	}
	bool AlgorithmParser::IsSingleOperator(char* token)
	{
		char* atoken = token;
		while(*atoken != '\0')
		{
			if(*atoken == '@' || *atoken == '$')
			{
				return true;
			}
			atoken ++;
		}
		return false;
	}
	int AlgorithmParser::GetperatorPriority(char* token)
	{
		if(token == NULL)
		{
			return -1;
		}
		else if(!strcmp(token,"("))
		{
			return 3;
		}
		else if(!strcmp(token,"*") || !strcmp(token,"/"))
		{
			return 2;
		}
		else if(!strcmp(token,"+") || !strcmp(token,"-") || !strcmp(token,"@") || !strcmp(token,"$"))
		{
			return 1;
		}
		else if(!strcmp(token,")"))
		{
			return -1;
		}
		return 0;
	}
	char* AlgorithmParser::Substring(char* src,int start,int len)
	{
		char* pString = src;
		char* retString = (char*)malloc(len + 1);
		char* pRetValue = retString;
		while(*pString && (pString - src) < len)
		{
			retString[( pString - src )] = *pString;
			pString ++;
		}
		retString[(pString - src)] = '\0';
		return pRetValue;

	}

}