qprocess.cpp

这是c++编程方面的名著的例子代码

#include <qprocess.h>
#include <strstream.h>
#include <algo.h>



query_processor::query_processor(String Input)
{

    char Character;
    InputString = Input;
    ValidExpression = 1;
    Character = '0';
    while(Character <= '9')
    {

	  ValidNumbers.insert(Character);
	  ValidOperands.insert(Character);
	  ValidCharacters.insert(Character);
	  Character++;
    }
    ValidOperators.insert('*');
    ValidOperators.insert('-');
    ValidOperators.insert('+');
    ValidOperators.insert('/');
    Character = 'a';
    while(Character <= 'z')
    {
	  ValidLetters.insert(Character);
	  ValidCharacters.insert(Character);
	  Character++;
    }
    Character = 'A';
    while(Character < 'Z')
    {
	  ValidLetters.insert(Character);
	  ValidCharacters.insert(Character);
	  Character++;
    }
    ValidCharacters.insert(' ');
    ValidCharacters.insert('.');
    ValidCharacters.insert(')');
    ValidCharacters.insert('(');
    ValidCharacters.insert('*');
    ValidCharacters.insert('/');
    ValidCharacters.insert('+');
    ValidCharacters.insert('-');

    ValidFunctions.insert("tan");
    ValidFunctions.insert("sqr");
    ValidFunctions.insert("log");
    ValidFunctions.insert("sin");
    ValidFunctions.insert("cos");
    ValidFunctions.insert("acos");
    ValidFunctions.insert("atan");
    ValidFunctions.insert("asin");

}

query_processor::query_processor(String Input,VSet VOperands,
				VSet VOperators,
				VSet VFunctions,
				VSet VCharacters,
				VSet VLetters,
				VSet VNumbers)
{
    ValidOperators = VOperators;
    ValidCharacters = VCharacters;
    ValidLetters = VLetters;
    ValidNumbers = VNumbers;
    InputString = Input;
    ValidExpression = 1;
   // copy(VFunctions.begin(),VFunctions.end(),ValidFunctions.begin());

}

query_processor::query_processor(void)
{
    char Character;
    ValidExpression = 1;
    Character = '0';
    while(Character <= '9')
    {

	  ValidNumbers.insert(Character);
	  ValidOperands.insert(Character);
	  ValidCharacters.insert(Character);
	  Character++;
    }
    ValidOperators.insert('*');
    ValidOperators.insert('-');
    ValidOperators.insert('+');
    ValidOperators.insert('/');
    Character = 'a';
    while(Character <= 'z')
    {
	  ValidCharacters.insert(Character);
	  ValidLetters.insert(Character);
	  Character++;
    }
    Character = 'A';
    while(Character < 'A')
    {
	  ValidLetters.insert(Character);
	  ValidCharacters.insert(Character);
	  Character++;
    }
    ValidCharacters.insert(' ');
    ValidCharacters.insert('.');
    ValidCharacters.insert(')');
    ValidCharacters.insert('(');
    ValidCharacters.insert('*');
    ValidCharacters.insert('/');
    ValidCharacters.insert('+');
    ValidCharacters.insert('-');

    ValidFunctions.insert("tan");
    ValidFunctions.insert("sqr");
    ValidFunctions.insert("log");
    ValidFunctions.insert("sin");
    ValidFunctions.insert("cos");
    ValidFunctions.insert("acos");
    ValidFunctions.insert("atan");
    ValidFunctions.insert("asin");


}

int query_processor::checkParenthesis(void)
{
   int LeftParen = 0;
   int RightParen = 0;
   int Count = 0;
   while((ValidExpression) && (Count < InputString.length()))
   {
      if(InputString[0] == ')'){
	 ValidExpression = 0;
      }
      if(InputString[InputString.length() -1] == '('){
	 ValidExpression = 0;
      }
      if(InputString[Count] == ')'){
	 RightParen++;
      }
      if(InputString[Count] == '('){
	 LeftParen++;
      }
      if(RightParen > LeftParen){
	 ValidExpression = 0;
      }
      Count++;
   }
   return(ValidExpression);

}


int query_processor::checkOperators(void)
{
   int Count = 0;
   while((Count <  InputString.length()) && (ValidExpression))
   {
       // checks for operators beginning a expression
       if((InputString[0] == '*') || (InputString[0] == '/') ||
	 (InputString[0] == '+')){
	  ValidExpression = 0;
       }
       // checks for operators ending a expression
       if(ValidOperators.count(InputString[InputString.length() -1])){
	   ValidExpression = 0;
       }

       // checks for consecutive operators
       if(ValidOperators.count(InputString[Count])){
	  if(ValidOperators.count(InputString[Count + 1])){
	     ValidExpression = 0;
	  }
	  if(Count > 0){
	     if(ValidOperators.count(InputString[Count - 1])){
	       ValidExpression = 0;
	     }
	  }
       }
       // checks for operators preceded by a character

       if(ValidOperators.count(InputString[Count])){
	  if(Count > 0){
	     if(ValidLetters.count((InputString[Count - 1]))){
		ValidExpression = 0;
	    }
	  }
       }
       Count++;

   }
   ValidOperators.insert('(');
   ValidOperators.insert(')');
   return(ValidExpression);
}

int query_processor::checkDecimals(void)
{
   int Count = 0;

   // checks for decimal beginning an expression

   if(InputString[0] == '.'){
      ValidExpression = 0;
   }
   // checks for decimal ending an expression

   if(InputString[InputString.length() - 1] == '.'){
      ValidExpression = 0;
   }
   // checks for consecutive decimal and for decimals preceding
   // or suceeding characters


   while((ValidExpression) && (Count < InputString.length()))
   {
      if(InputString[Count] == '.'){
	 if((InputString[Count + 1] == '.') || (InputString[Count - 1] == '.')){
	    ValidExpression = 0;
	 }
	 if((ValidLetters.count((InputString[Count + 1]))) || (ValidLetters.count((InputString[Count - 1])))){
	     ValidExpression = 0;
	 }
      }
      Count++;
   }
   return(ValidExpression);
}

int query_processor::checkCharacters(void)
{
   int Count = 0;
   while((Count < InputString.length()) && (ValidExpression))
   {
      if(!ValidCharacters.count(InputString[Count])){
	 ValidExpression = 0;
      }
      Count++;
   }
   return(ValidExpression);
}


String query_processor::inputString(void)
{
   return(InputString);
}

void query_processor::inputString(String Input)
{
   InputString = Input;
}

int query_processor::validExpression(void)
{
    return(ValidExpression);
}

char *query_processor::processFunction(int &Count)
{

    strcpy(FunctionResult,"");
    strstream FunctionName;

    do{
	   if(ValidLetters.count(InputString[Count])){
	      FunctionName << InputString[Count];
	   }
	   Count++;
    }while(ValidLetters.count(InputString[Count]) && (Count < InputString.length()));
    FunctionName << ends;
    FunctionName >> FunctionResult;
    String F(FunctionResult);
    if(ValidFunctions.count(F) == 0){
       ValidExpression = 0;
       strcpy(FunctionResult,"");
    }
    Count--;
    return(FunctionResult);
}


int query_processor::parse(void)
{
     double NumericResult = 0;
     char FunctionName[10] = "";
     int Count= 0;
     while(Count < InputString.length())
     {
	 if(InputString[Count] == ' '){
	    Count++;
	 }
	 if(ValidOperators.count(InputString[Count]) == 0){
	    if(ValidNumbers.count(InputString[Count])){
	       expression_component TempToken;
	       NumericResult = processNumber(Count);
	       TempToken.isOperand(1);
	       TempToken.value(NumericResult);
	       ExpressionTokens.push_back(TempToken);

	    }
	    else{
		    if(ValidLetters.count(InputString[Count])){
		       expression_component TempToken;
		       strcpy(FunctionName,processFunction(Count));
		       TempToken.function(FunctionName);
		       TempToken.isOperator(1);
		       TempToken.isFunction(1);
		       TempToken.op('@');
		       ExpressionTokens.push_back(TempToken);
		    }
	    }
	 }
	 else{
	       expression_component TempToken;
	       TempToken.op(InputString[Count]);
	       TempToken.isOperator(1);
	       ExpressionTokens.push_back(TempToken);

	 }
	 Count++;

     }
     return(ValidExpression);

}



double query_processor::processNumber(int &Count)
{
     double TempNumber;
     int DecimalCount = 0;
     strstream Number;
     int NotFinish = 1;

     do{
	   if(InputString[Count] == '.'){
	      DecimalCount++;
	   }
	   if((ValidNumbers.count(InputString[Count])) || (InputString[Count] == '.')){
	      Number << InputString[Count];
	      Count++;
	   }
	   else{
		 NotFinish = 0;
	   }

     }while((Count < InputString.length()) && (DecimalCount <=1) && (NotFinish));
     if(DecimalCount <= 1){
	Number << ends;
	Number >> TempNumber;
     }
     else{
	   TempNumber = 0;
	   ValidExpression = 0;
     }
    

     Count--;
     return(TempNumber);
}

list<expression_component> query_processor::expressionToken(void)
{

      return(ExpressionTokens);
}

int query_processor::validate(void)
{

    if(checkParenthesis() == 0){
	return(0);
     }
     if(checkDecimals() == 0){
	return(0);
     }
     if(checkOperators() == 0){
	return(0);
     }
     if(checkCharacters() == 0){
	return(0);
     }
     return(1);
}

void query_processor::process(void)
{
     if(validate()){
	parse();
	evaluate();
     }
}