expproc.cpp

一个通讯管理机的源代码。比较好用。推荐

       xb_error(XB_PARSE_ERROR);
}

   memset( Operator, 0x00, 6 /*3*/ );  // changed for logical ops 3/26/00 dtb
   strncpy( Operator, WorkNode->NodeText, WorkNode->Len );
//printf("Operator = '%s'\n", Operator);
   if( !WorkNode->InTree ) 
      delete WorkNode;
   /* load up operand 1 */
   WorkNode = (xbExpNode *) Pop();
//printf("Operand 1 WorkNode->Type = '%c'\n", WorkNode->Type);
   if(( OpType1 = GetOperandType( WorkNode )) == 0 )
     xb_error(XB_PARSE_ERROR);

   if( OpLen1 < WorkNode->DataLen+1 && WorkNode->Type != 'd' ) {
      if( OpLen1 > 0 ) free( Op1 );
      if(( Op1 = (char *) malloc( WorkNode->DataLen+1 )) == NULL ) {
         xb_memory_error;
      }
      OpLen1 = WorkNode->DataLen+1;
   }
   OpDataLen1 = WorkNode->DataLen;
   memset( Op1, 0x00, WorkNode->DataLen+1 );
   if( WorkNode->Type == 'D' && WorkNode->dbf ) {    /* database field  */
      WorkNode->dbf->GetField( WorkNode->FieldNo, Op1, RecBufSw );
      t = WorkNode->dbf->GetFieldType( WorkNode->FieldNo );
      if( t == 'N' || t == 'F' )
         Opd1 = strtod( WorkNode->StringResult, 0 );
   }
   else if( WorkNode->Type == 'C' )     /* constant        */
      memcpy( Op1, WorkNode->NodeText, WorkNode->DataLen );
   else if( WorkNode->Type == 's' )     /* previous result */
      memcpy( Op1, WorkNode->StringResult, WorkNode->DataLen+1 );
   else if( WorkNode->Type == 'd' )     /* previous numeric result */   
      Opd1 = WorkNode->DoubResult;
   else if( WorkNode->Type == 'N' )     /* previous numeric result */   
      Opd1 = strtod( WorkNode->StringResult, 0 );
   else if(WorkNode->Type == 'l')       /* previous logical result 3/26/00 dtb */
      Opd1 = WorkNode->IntResult;
   if( !WorkNode->InTree ) 
      delete WorkNode;

   /* load up operand 2 */
   WorkNode = (xbExpNode *) Pop();
//printf("Operand 2 WorkNode->Type = '%c'\n", WorkNode->Type);
   if(( OpType2 = GetOperandType( WorkNode )) == 0 )
     xb_error(XB_PARSE_ERROR);

   if( OpLen2 < WorkNode->DataLen+1 && WorkNode->Type != 'd' ) {
      if( OpLen2 > 0 ) free( Op2 );
      if(( Op2 = (char *) malloc( WorkNode->DataLen+1 )) == NULL ) {
        xb_memory_error;
      }
      OpLen2 = WorkNode->DataLen+1;
   }
   OpDataLen2 = WorkNode->DataLen;
   memset( Op2, 0x00, WorkNode->DataLen+1 );
   if( WorkNode->Type == 'D' && WorkNode->dbf ) {    /* database field  */
      WorkNode->dbf->GetField( WorkNode->FieldNo, Op2, RecBufSw );
      t = WorkNode->dbf->GetFieldType( WorkNode->FieldNo );
      if( t == 'N' || t == 'F' )
         Opd2 = strtod( WorkNode->StringResult, 0 );
   }
   else if( WorkNode->Type == 'C' )     /* constant        */
      memcpy( Op2, WorkNode->NodeText, WorkNode->DataLen );
   else if( WorkNode->Type == 's' )     /* previous result */
      memcpy( Op2, WorkNode->StringResult, WorkNode->DataLen+1 );
   else if( WorkNode->Type == 'd' )     /* previous numeric result */
      Opd2 = WorkNode->DoubResult;
   else if( WorkNode->Type == 'N' )     /* previous numeric result */   
      Opd2 = strtod( WorkNode->StringResult, 0 );
   else if(WorkNode->Type == 'l')       /* previous logical result 3/26/00 dtb*/
      Opd2 = WorkNode->IntResult;
   if( !WorkNode->InTree )
      delete WorkNode;
   if( !ValidOperation( Operator, OpType1, OpType2 ))
      xb_error(XB_PARSE_ERROR);

   if( OpType1 == 'N' || OpType1 == 'L')    /* numeric procesing */
   {
      return NumericOperation( Operator );
   }
   else                    /* must be character */
      return  AlphaOperation( Operator );
}
/*************************************************************************/
//! Short description
/*!
  \param Operator
*/
xbShort xbExpn::NumericOperation( char * Operator )
{
   xbDouble  Operand1, Operand2;
   xbExpNode * WorkNode;
   xbShort   ResultLen;
   char      SaveType;
   ResultLen = 0;

//printf("NumericOperation(%s)\n", Operator);

   if( Operator[0] == '=' || Operator[0] == '<' || 
       Operator[0] == '>' || Operator[0] == '#'  ||
       Operator[0] == '.')
      SaveType = 'l';
   else
      SaveType = 'd';

   if(( WorkNode = GetExpNode( ResultLen )) == NULL )
     xb_error(XB_PARSE_ERROR);

   WorkNode->Type = SaveType;
   WorkNode->DataLen = ResultLen;

   if( OpType1 == 'd' || OpType1 == 'N' )
      Operand1 = Opd1;
   else
      Operand1 = strtod( Op1, NULL );

   if( OpType2 == 'd' || OpType2 == 'N' )
      Operand2 =  Opd2;
   else
      Operand2 = strtod( Op2, NULL );

   if( Operator[0] == '*' && Operator[1] == '*' )
      WorkNode->DoubResult = pow( Operand2, Operand1 );
   else if( Operator[0] == '*' )
      WorkNode->DoubResult = Operand2 * Operand1;
   else if( Operator[0] == '/') 
      WorkNode->DoubResult = Operand2 / Operand1;
   else if( Operator[0] == '+' )
      WorkNode->DoubResult = Operand2 + Operand1;
   else if( Operator[0] == '-' )
      WorkNode->DoubResult = Operand2 - Operand1;

   /* = */
   else if((Operator[0]== '=' || Operator[1]== '=' ) && Operand1 == Operand2)
      WorkNode->IntResult = 1;
   else if( Operator[0] == '=' )
      WorkNode->IntResult = 0;
   /* not = */
   else if((Operator[0] == '<' && Operator[1] == '>')||Operator[0] == '#') {
      if( Operand1 != Operand2 )
         WorkNode->IntResult = 1;
      else
         WorkNode->IntResult = 0;
   }
   /* less than */
   else if( Operator[0] == '<' ) {
      if( Operand2 < Operand1 )
         WorkNode->IntResult = 1;
      else
         WorkNode->IntResult = 0;
   }
   /* greater than */
   else if( Operator[0] == '>' ) {
      if( Operand2 > Operand1 )
         WorkNode->IntResult = 1;
      else
         WorkNode->IntResult = 0;
   }
   else if(Operator[0] == '.') // logical operators, added 3/26/00 dtb
   {
//printf("Operand1 = %d, Operand2 = %d\n", Operand1, Operand2);
     switch(Operator[1])
     {
       case 'A' : // and
         WorkNode->IntResult = (Opd1 && Opd2) ? 1 : 0;
       break;
       
       case 'N' : // not
         WorkNode->IntResult = (!(Opd1 && Opd2)) ? 1 : 0;
       break;
       
       case 'O' : // or
         WorkNode->IntResult = (Opd1 || Opd2) ? 1 : 0;
       break;
       
       default :
         xb_error(XB_PARSE_ERROR);
     }
   }
   else
      xb_error(XB_PARSE_ERROR);

   Push((void *) WorkNode );
   return 0;
}
/*************************************************************************/
//! Short description
/*!
  \param Operator
*/
xbShort xbExpn::AlphaOperation( char * Operator )
{
   xbShort ResultLen, i;
   char SaveType;
   xbExpNode * WorkNode;

//printf("AlphaOperation(%s): Op1 = '%*s', Op2 = '%*s'\n", Operator,
//       OpDataLen1, Op1, OpDataLen2, Op2);

   if( Operator[0] == '=' || Operator[0] == '<' || 
       Operator[0] == '>' || Operator[0] == '#'  ||
       Operator[0] == '$')
   {
      ResultLen = 0;
      SaveType = 'l';
   }
   else {
      ResultLen = OpDataLen1 + OpDataLen2 + 1;
      SaveType = 's';
   }
   if(( WorkNode = GetExpNode( ResultLen )) == NULL )
     xb_error(XB_PARSE_ERROR);

   WorkNode->Type = SaveType;
   if( WorkNode->Type == 'l' )
      WorkNode->DataLen = 0;
   else
      WorkNode->DataLen = ResultLen - 1;

   if( Operator[0] == '+' ) {
     WorkNode->StringResult = Op2;
     WorkNode->StringResult += Op1;
   }
   else if( Operator[0] == '-' ) {
      WorkNode->StringResult = LTRIM( Op2 );
      WorkNode->StringResult += Op1;
      i = WorkNode->StringResult.len();
      for( ; i < ResultLen-1; i++)
         WorkNode->StringResult += " ";
   }
   /* = */
   else if((Operator[0]== '=' || Operator[1]== '=' ) && strcmp(Op1,Op2) == 0)
      WorkNode->IntResult = 1;
   else if( Operator[0] == '=' )
      WorkNode->IntResult = 0;
   /* not = */
   else if((Operator[0] == '<' && Operator[1] == '>')||Operator[0] == '#') {
      if( strcmp( Op1, Op2 ) != 0 )
         WorkNode->IntResult = 1;
      else
         WorkNode->IntResult = 0;
   }
   /* less than */
   else if( Operator[0] == '<' )
   {
      if( strcmp( Op2, Op1 ) < 0 )
         WorkNode->IntResult = 1;
      else
         WorkNode->IntResult = 0;
   }
   /* greater than */
   else if( Operator[0] == '>' )
   {
      if( strcmp( Op2, Op1 ) > 0 )
         WorkNode->IntResult = 1;
      else
         WorkNode->IntResult = 0;
   }
   //  contains, added 3/26/00 dtb
   else if(Operator[0] == '$')
   {
     if(strstr(Op2, Op1))
       WorkNode->IntResult = 1;
     else
       WorkNode->IntResult = 0;
   }
   else
     xb_error(XB_PARSE_ERROR);

//printf("WorkNode->IntResult = %d\n", WorkNode->IntResult);
   Push((void *) WorkNode);
   return XB_NO_ERROR;
}
/*************************************************************************/
#endif   // XB_EXPRESSIONS