c55dab446f
git-svn-id: https://svn.code.sf.net/p/flaim/code/trunk@7 0109f412-320b-0410-ab79-c3e0c5ffbbe6
2567 lines
56 KiB
C++
2567 lines
56 KiB
C++
//------------------------------------------------------------------------------
|
|
// Desc: Contains the methods for doing evaluation of query expressions.
|
|
//
|
|
// Tabs: 3
|
|
//
|
|
// Copyright (c) 2003-2006 Novell, Inc. All Rights Reserved.
|
|
//
|
|
// This program is free software; you can redistribute it and/or
|
|
// modify it under the terms of version 2 of the GNU General Public
|
|
// License as published by the Free Software Foundation.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program; if not, contact Novell, Inc.
|
|
//
|
|
// To contact Novell about this file by physical or electronic mail,
|
|
// you may find current contact information at www.novell.com
|
|
//
|
|
// $Id: fqeval.cpp 3114 2006-01-19 13:22:45 -0700 (Thu, 19 Jan 2006) dsanders $
|
|
//------------------------------------------------------------------------------
|
|
|
|
#include "flaimsys.h"
|
|
#include "fquery.h"
|
|
|
|
FSTATIC RCODE fqApproxCompare(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FLMINT * piResult);
|
|
|
|
FSTATIC RCODE fqCompareBinary(
|
|
IF_OperandComparer * pOpComparer,
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FLMINT * piResult);
|
|
|
|
FSTATIC RCODE fqCompareText(
|
|
IF_OperandComparer * pOpComparer,
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FLMUINT uiCompareRules,
|
|
FLMBOOL bOpIsMatch,
|
|
FLMUINT uiLanguage,
|
|
FLMINT * piResult);
|
|
|
|
FSTATIC void fqOpUUBitAND(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpUUBitOR(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpUUBitXOR(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpUUMult(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpUSMult(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpSSMult(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpSUMult(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpUUDiv(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpUSDiv(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpSSDiv(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpSUDiv(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpUUMod(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpUSMod(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpSSMod(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpSUMod(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpUUPlus(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpUSPlus(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpSSPlus(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpSUPlus(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpUUMinus(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpUSMinus(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpSSMinus(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FSTATIC void fqOpSUMinus(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
typedef void FQ_OPERATION(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult);
|
|
|
|
FQ_OPERATION * FQ_ArithOpTable[
|
|
((XFLM_LAST_ARITH_OP - XFLM_FIRST_ARITH_OP) + 1) * 4 ] =
|
|
{
|
|
/* U = Unsigned S = Signed
|
|
U + U U + S
|
|
S + U S + S */
|
|
/* BITAND */ fqOpUUBitAND, fqOpUUBitAND,
|
|
fqOpUUBitAND, fqOpUUBitAND,
|
|
/* BITOR */ fqOpUUBitOR, fqOpUUBitOR,
|
|
fqOpUUBitOR, fqOpUUBitOR,
|
|
/* BITXOR */ fqOpUUBitXOR, fqOpUUBitXOR,
|
|
fqOpUUBitXOR, fqOpUUBitXOR,
|
|
/* MULT */ fqOpUUMult, fqOpUSMult,
|
|
fqOpSUMult, fqOpSSMult,
|
|
/* DIV */ fqOpUUDiv, fqOpUSDiv,
|
|
fqOpSUDiv, fqOpSSDiv,
|
|
/* MOD */ fqOpUUMod, fqOpUSMod,
|
|
fqOpSUMod, fqOpSSMod,
|
|
/* PLUS */ fqOpUUPlus, fqOpUSPlus,
|
|
fqOpSUPlus, fqOpSSPlus,
|
|
/* MINUS */ fqOpUUMinus, fqOpUSMinus,
|
|
fqOpSUMinus, fqOpSSMinus
|
|
};
|
|
|
|
/***************************************************************************
|
|
Desc: Returns a 64-bit unsigned integer
|
|
***************************************************************************/
|
|
FINLINE FLMUINT64 fqGetUInt64(
|
|
FQVALUE * pValue)
|
|
{
|
|
if (pValue->eValType == XFLM_UINT_VAL)
|
|
{
|
|
return( (FLMUINT64)pValue->val.uiVal);
|
|
}
|
|
else if( pValue->eValType == XFLM_UINT64_VAL)
|
|
{
|
|
return( pValue->val.ui64Val);
|
|
}
|
|
else if( pValue->eValType == XFLM_INT64_VAL)
|
|
{
|
|
if( pValue->val.i64Val >= 0)
|
|
{
|
|
return( (FLMUINT64)pValue->val.i64Val);
|
|
}
|
|
}
|
|
else if( pValue->eValType == XFLM_INT_VAL)
|
|
{
|
|
if( pValue->val.iVal >= 0)
|
|
{
|
|
return( (FLMUINT64)pValue->val.iVal);
|
|
}
|
|
}
|
|
|
|
flmAssert( 0);
|
|
return( 0);
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Returns a 64-bit signed integer
|
|
***************************************************************************/
|
|
FINLINE FLMINT64 fqGetInt64(
|
|
FQVALUE * pValue)
|
|
{
|
|
if (pValue->eValType == XFLM_INT_VAL)
|
|
{
|
|
return( (FLMINT64)pValue->val.iVal);
|
|
}
|
|
else if( pValue->eValType == XFLM_INT64_VAL)
|
|
{
|
|
return( pValue->val.i64Val);
|
|
}
|
|
else if( pValue->eValType == XFLM_UINT_VAL)
|
|
{
|
|
return( (FLMINT64)pValue->val.uiVal);
|
|
}
|
|
else if( pValue->eValType == XFLM_UINT64_VAL)
|
|
{
|
|
if( pValue->val.ui64Val <= (FLMUINT64)FLM_MAX_INT64)
|
|
{
|
|
return( (FLMINT64)pValue->val.ui64Val);
|
|
}
|
|
}
|
|
|
|
flmAssert( 0);
|
|
return( 0);
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs the bit and operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpUUBitAND(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
pResult->val.uiVal = pLValue->val.uiVal & pRValue->val.uiVal;
|
|
pResult->eValType = XFLM_UINT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.ui64Val =
|
|
fqGetUInt64( pLValue) & fqGetUInt64( pRValue);
|
|
pResult->eValType = XFLM_UINT64_VAL;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs the bit or operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpUUBitOR(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
pResult->val.uiVal = pLValue->val.uiVal | pRValue->val.uiVal;
|
|
pResult->eValType = XFLM_UINT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.ui64Val =
|
|
fqGetUInt64( pLValue) | fqGetUInt64( pRValue);
|
|
pResult->eValType = XFLM_UINT64_VAL;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs the bit xor operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpUUBitXOR(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
pResult->val.uiVal = pLValue->val.uiVal ^ pRValue->val.uiVal;
|
|
pResult->eValType = XFLM_UINT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.ui64Val =
|
|
fqGetUInt64( pLValue) ^ fqGetUInt64( pRValue);
|
|
pResult->eValType = XFLM_UINT64_VAL;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs the multiply operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpUUMult(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
pResult->val.uiVal = pLValue->val.uiVal * pRValue->val.uiVal;
|
|
pResult->eValType = XFLM_UINT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.ui64Val =
|
|
fqGetUInt64( pLValue) * fqGetUInt64( pRValue);
|
|
pResult->eValType = XFLM_UINT64_VAL;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs the multiply operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpUSMult(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
pResult->val.iVal = (FLMINT)pLValue->val.uiVal * pRValue->val.iVal;
|
|
pResult->eValType = XFLM_INT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.i64Val = (FLMINT64)
|
|
fqGetUInt64( pLValue) * fqGetInt64( pRValue);
|
|
pResult->eValType = XFLM_INT64_VAL;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs the multiply operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpSSMult(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
pResult->val.iVal = pLValue->val.iVal * pRValue->val.iVal;
|
|
pResult->eValType = (pResult->val.iVal < 0)
|
|
? XFLM_INT_VAL
|
|
: XFLM_UINT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.i64Val = (FLMINT64)(fqGetInt64( pLValue) *
|
|
fqGetInt64( pRValue));
|
|
|
|
pResult->eValType = (pResult->val.i64Val < 0)
|
|
? XFLM_INT64_VAL
|
|
: XFLM_UINT64_VAL;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs the multiply operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpSUMult(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
pResult->val.iVal = pLValue->val.iVal *
|
|
(FLMINT)pRValue->val.uiVal;
|
|
pResult->eValType = XFLM_INT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.i64Val = (FLMINT64)
|
|
(fqGetInt64( pLValue) * fqGetUInt64( pRValue));
|
|
pResult->eValType = XFLM_INT64_VAL;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs the divide operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpUUDiv(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
if( pRValue->val.uiVal)
|
|
{
|
|
pResult->val.uiVal = pLValue->val.uiVal / pRValue->val.uiVal;
|
|
pResult->eValType = XFLM_UINT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.uiVal = 0; // Divide by ZERO case.
|
|
pResult->eValType = XFLM_MISSING_VAL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FLMUINT64 ui64LValue = fqGetUInt64( pLValue);
|
|
FLMUINT64 ui64RValue = fqGetUInt64( pRValue);
|
|
|
|
if( ui64RValue)
|
|
{
|
|
pResult->val.ui64Val = ui64LValue / ui64RValue;
|
|
pResult->eValType = XFLM_UINT64_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.uiVal = 0; // Divide by ZERO case.
|
|
pResult->eValType = XFLM_MISSING_VAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs the divide operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpUSDiv(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
if( pRValue->val.iVal)
|
|
{
|
|
pResult->val.iVal = pLValue->val.uiVal / pRValue->val.iVal;
|
|
pResult->eValType = XFLM_INT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.uiVal = 0; // Divide by ZERO case.
|
|
pResult->eValType = XFLM_MISSING_VAL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FLMUINT64 ui64LValue = fqGetUInt64( pLValue);
|
|
FLMINT64 i64RValue = fqGetInt64( pRValue);
|
|
|
|
if( i64RValue)
|
|
{
|
|
pResult->val.i64Val = ui64LValue / i64RValue;
|
|
pResult->eValType = XFLM_INT64_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.uiVal = 0; // Divide by ZERO case.
|
|
pResult->eValType = XFLM_MISSING_VAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs the divide operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpSSDiv(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
if( pRValue->val.iVal)
|
|
{
|
|
pResult->val.iVal = pLValue->val.iVal / pRValue->val.iVal;
|
|
pResult->eValType = (pResult->val.iVal < 0)
|
|
? XFLM_INT_VAL : XFLM_UINT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.uiVal = 0; // Divide by ZERO case.
|
|
pResult->eValType = XFLM_MISSING_VAL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FLMINT64 i64LValue = fqGetInt64( pLValue);
|
|
FLMINT64 i64RValue = fqGetInt64( pRValue);
|
|
|
|
if( i64RValue)
|
|
{
|
|
pResult->val.i64Val = i64LValue / i64RValue;
|
|
pResult->eValType = (pResult->val.i64Val < 0)
|
|
? XFLM_INT64_VAL : XFLM_UINT64_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.uiVal = 0; // Divide by ZERO case.
|
|
pResult->eValType = XFLM_MISSING_VAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs the divide operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpSUDiv(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
if( pRValue->val.uiVal)
|
|
{
|
|
pResult->val.iVal = pLValue->val.iVal / pRValue->val.uiVal;
|
|
pResult->eValType = XFLM_INT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.uiVal = 0; // Divide by ZERO case.
|
|
pResult->eValType = XFLM_MISSING_VAL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FLMINT64 i64LValue = fqGetInt64( pLValue);
|
|
FLMUINT64 ui64RValue = fqGetUInt64( pRValue);
|
|
|
|
if( ui64RValue)
|
|
{
|
|
pResult->val.i64Val = i64LValue / ui64RValue;
|
|
pResult->eValType = XFLM_INT64_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.uiVal = 0; // Divide by ZERO case.
|
|
pResult->eValType = XFLM_MISSING_VAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs the modulo operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpUUMod(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
if( pRValue->val.uiVal)
|
|
{
|
|
pResult->val.uiVal = pLValue->val.uiVal % pRValue->val.uiVal;
|
|
pResult->eValType = XFLM_UINT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.uiVal = 0; // MOD by ZERO case.
|
|
pResult->eValType = XFLM_MISSING_VAL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FLMUINT64 ui64LValue = fqGetUInt64( pLValue);
|
|
FLMUINT64 ui64RValue = fqGetUInt64( pRValue);
|
|
|
|
if( ui64RValue)
|
|
{
|
|
pResult->val.ui64Val = ui64LValue % ui64RValue;
|
|
pResult->eValType = XFLM_UINT64_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.uiVal = 0; // MOD by ZERO case.
|
|
pResult->eValType = XFLM_MISSING_VAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs the modulo operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpUSMod(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
if( pRValue->val.iVal)
|
|
{
|
|
pResult->val.iVal = pLValue->val.uiVal % pRValue->val.iVal;
|
|
pResult->eValType = XFLM_INT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.uiVal = 0; // MOD by ZERO case.
|
|
pResult->eValType = XFLM_MISSING_VAL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FLMUINT64 ui64LValue = fqGetUInt64( pLValue);
|
|
FLMINT64 i64RValue = fqGetInt64( pRValue);
|
|
|
|
if( i64RValue)
|
|
{
|
|
pResult->val.i64Val = ui64LValue % i64RValue;
|
|
pResult->eValType = XFLM_INT64_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.uiVal = 0; // MOD by ZERO case.
|
|
pResult->eValType = XFLM_MISSING_VAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs the modulo operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpSSMod(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
if( pRValue->val.iVal)
|
|
{
|
|
pResult->val.iVal = pLValue->val.iVal % pRValue->val.iVal;
|
|
pResult->eValType = (pResult->val.iVal < 0)
|
|
? XFLM_INT_VAL : XFLM_UINT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.uiVal = 0; // MOD by ZERO case.
|
|
pResult->eValType = XFLM_MISSING_VAL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FLMINT64 i64LValue = fqGetInt64( pLValue);
|
|
FLMINT64 i64RValue = fqGetInt64( pRValue);
|
|
|
|
if( i64RValue)
|
|
{
|
|
pResult->val.i64Val = i64LValue % i64RValue;
|
|
pResult->eValType = (pResult->val.i64Val < 0)
|
|
? XFLM_INT64_VAL : XFLM_UINT64_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.uiVal = 0; // MOD by ZERO case.
|
|
pResult->eValType = XFLM_MISSING_VAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs the modulo operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpSUMod(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
if( pRValue->val.uiVal)
|
|
{
|
|
pResult->val.iVal = pLValue->val.iVal % pRValue->val.uiVal;
|
|
pResult->eValType = XFLM_INT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.uiVal = 0; // MOD by ZERO case.
|
|
pResult->eValType = XFLM_MISSING_VAL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FLMINT64 i64LValue = fqGetInt64( pLValue);
|
|
FLMUINT64 ui64RValue = fqGetUInt64( pRValue);
|
|
|
|
if( ui64RValue)
|
|
{
|
|
pResult->val.i64Val = i64LValue % ui64RValue;
|
|
pResult->eValType = XFLM_INT64_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.uiVal = 0; // MOD by ZERO case.
|
|
pResult->eValType = XFLM_MISSING_VAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs an addition operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpUUPlus(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
pResult->val.uiVal = pLValue->val.uiVal + pRValue->val.uiVal;
|
|
pResult->eValType = XFLM_UINT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.ui64Val =
|
|
fqGetUInt64( pLValue) + fqGetUInt64( pRValue);
|
|
pResult->eValType = XFLM_UINT64_VAL;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs an addition operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpUSPlus(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
if( (pRValue->val.iVal >= 0) ||
|
|
(pLValue->val.uiVal > gv_uiMaxSignedIntVal))
|
|
{
|
|
pResult->val.uiVal = pLValue->val.uiVal + (FLMUINT)pRValue->val.iVal;
|
|
pResult->eValType = XFLM_UINT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.iVal = (FLMINT)pLValue->val.uiVal + pRValue->val.iVal;
|
|
pResult->eValType = (pResult->val.iVal < 0)
|
|
? XFLM_INT_VAL : XFLM_UINT_VAL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FLMUINT64 ui64LValue = fqGetUInt64( pLValue);
|
|
FLMINT64 i64RValue = fqGetInt64( pRValue);
|
|
|
|
if( (i64RValue >= 0) || (ui64LValue > gv_ui64MaxSignedIntVal))
|
|
{
|
|
pResult->val.ui64Val = ui64LValue + (FLMUINT64)i64RValue;
|
|
pResult->eValType = XFLM_UINT64_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.i64Val = (FLMINT64)ui64LValue + i64RValue;
|
|
pResult->eValType = (pResult->val.i64Val < 0)
|
|
? XFLM_INT64_VAL : XFLM_UINT64_VAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs an addition operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpSSPlus(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
pResult->val.iVal = pLValue->val.iVal + pRValue->val.iVal;
|
|
pResult->eValType = (pResult->val.iVal < 0)
|
|
? XFLM_INT_VAL : XFLM_UINT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.i64Val =
|
|
fqGetInt64( pLValue) + fqGetInt64( pRValue);
|
|
pResult->eValType = (pResult->val.i64Val < 0)
|
|
? XFLM_INT64_VAL : XFLM_UINT64_VAL;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs an addition operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpSUPlus(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
if( (pLValue->val.iVal >= 0) ||
|
|
(pRValue->val.uiVal > gv_uiMaxSignedIntVal))
|
|
{
|
|
pResult->val.uiVal = (FLMUINT)pLValue->val.iVal + pRValue->val.uiVal;
|
|
pResult->eValType = XFLM_UINT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.iVal = pLValue->val.iVal + (FLMINT)pRValue->val.uiVal;
|
|
pResult->eValType = (pResult->val.iVal < 0)
|
|
? XFLM_INT_VAL : XFLM_UINT_VAL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FLMINT64 i64LValue = fqGetInt64( pLValue);
|
|
FLMUINT64 ui64RValue = fqGetUInt64( pRValue);
|
|
|
|
if( (i64LValue >= 0) || (ui64RValue > gv_ui64MaxSignedIntVal))
|
|
{
|
|
pResult->val.ui64Val = (FLMUINT64)i64LValue + ui64RValue;
|
|
pResult->eValType = XFLM_UINT64_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.i64Val = i64LValue + (FLMINT64)ui64RValue;
|
|
pResult->eValType = (pResult->val.i64Val < 0)
|
|
? XFLM_INT64_VAL : XFLM_UINT64_VAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs a subtraction operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpUUMinus(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
if( pLValue->val.uiVal >= pRValue->val.uiVal)
|
|
{
|
|
pResult->val.uiVal = pLValue->val.uiVal - pRValue->val.uiVal;
|
|
pResult->eValType = XFLM_UINT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.iVal = (FLMINT)(pLValue->val.uiVal - pRValue->val.uiVal);
|
|
pResult->eValType = XFLM_INT_VAL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FLMUINT64 ui64LValue = fqGetUInt64( pLValue);
|
|
FLMUINT64 ui64RValue = fqGetUInt64( pRValue);
|
|
|
|
if( ui64LValue >= ui64RValue)
|
|
{
|
|
pResult->val.ui64Val = ui64LValue - ui64RValue;
|
|
pResult->eValType = XFLM_UINT64_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.i64Val = (FLMINT64)(ui64LValue - ui64RValue);
|
|
pResult->eValType = XFLM_INT64_VAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs a subtraction operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpUSMinus(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
if( pRValue->val.iVal < 0)
|
|
{
|
|
pResult->val.uiVal = pLValue->val.uiVal - pRValue->val.iVal;
|
|
pResult->eValType = XFLM_UINT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.iVal = (FLMINT)pLValue->val.uiVal - pRValue->val.iVal;
|
|
pResult->eValType = (pResult->val.iVal < 0)
|
|
? XFLM_INT_VAL : XFLM_UINT_VAL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FLMUINT64 ui64LValue = fqGetUInt64( pLValue);
|
|
FLMINT64 i64RValue = fqGetInt64( pRValue);
|
|
|
|
if( i64RValue < 0)
|
|
{
|
|
pResult->val.ui64Val = ui64LValue - i64RValue;
|
|
pResult->eValType = XFLM_UINT64_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.i64Val = (FLMINT64)ui64LValue - i64RValue;
|
|
pResult->eValType = (pResult->val.i64Val < 0)
|
|
? XFLM_INT64_VAL : XFLM_UINT64_VAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs a subtraction operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpSSMinus(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
if(( pLValue->val.iVal > 0) && ( pRValue->val.iVal < 0))
|
|
{
|
|
pResult->val.uiVal = (FLMUINT)(pLValue->val.iVal - pRValue->val.iVal);
|
|
pResult->eValType = XFLM_UINT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.iVal = pLValue->val.iVal - pRValue->val.iVal;
|
|
pResult->eValType = (pResult->val.iVal < 0)
|
|
? XFLM_INT_VAL : XFLM_UINT_VAL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FLMINT64 i64LValue = fqGetInt64( pLValue);
|
|
FLMINT64 i64RValue = fqGetInt64( pRValue);
|
|
|
|
if( (i64LValue > 0) && (i64RValue < 0))
|
|
{
|
|
pResult->val.ui64Val = (FLMUINT64)( i64LValue - i64RValue);
|
|
pResult->eValType = XFLM_UINT64_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.i64Val = i64LValue - i64RValue;
|
|
pResult->eValType = (pResult->val.i64Val < 0)
|
|
? XFLM_INT64_VAL : XFLM_UINT64_VAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs a subtraction operation
|
|
***************************************************************************/
|
|
FSTATIC void fqOpSUMinus(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FQVALUE * pResult)
|
|
{
|
|
if( isNativeNum( pLValue->eValType) &&
|
|
isNativeNum( pRValue->eValType))
|
|
{
|
|
if( pRValue->val.uiVal > gv_uiMaxSignedIntVal)
|
|
{
|
|
pResult->val.iVal = (pLValue->val.iVal - gv_uiMaxSignedIntVal) -
|
|
(FLMINT)(pRValue->val.uiVal - gv_uiMaxSignedIntVal);
|
|
pResult->eValType = XFLM_INT_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.iVal = pLValue->val.iVal - (FLMINT)pRValue->val.uiVal;
|
|
pResult->eValType = (pResult->val.iVal < 0)
|
|
? XFLM_INT_VAL : XFLM_UINT_VAL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FLMINT64 i64LValue = fqGetInt64( pLValue);
|
|
FLMUINT64 ui64RValue = fqGetUInt64( pRValue);
|
|
|
|
if( ui64RValue > gv_ui64MaxSignedIntVal)
|
|
{
|
|
pResult->val.i64Val = (i64LValue - gv_ui64MaxSignedIntVal) -
|
|
(FLMINT64)(ui64RValue - gv_ui64MaxSignedIntVal);
|
|
pResult->eValType = XFLM_INT64_VAL;
|
|
}
|
|
else
|
|
{
|
|
pResult->val.i64Val = i64LValue - (FLMINT64)ui64RValue;
|
|
pResult->eValType = (pResult->val.i64Val < 0)
|
|
? XFLM_INT64_VAL : XFLM_UINT64_VAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Compare two entire strings.
|
|
****************************************************************************/
|
|
RCODE fqCompareCollStreams(
|
|
F_CollIStream * pLStream,
|
|
F_CollIStream * pRStream,
|
|
FLMBOOL bOpIsMatch,
|
|
FLMUINT uiLanguage,
|
|
FLMINT * piResult)
|
|
{
|
|
RCODE rc = NE_XFLM_OK;
|
|
FLMUINT16 ui16RCol;
|
|
FLMUINT16 ui16LCol;
|
|
FLMUINT16 ui16RSubCol;
|
|
FLMUINT16 ui16LSubCol;
|
|
FLMBYTE ucRCase;
|
|
FLMBYTE ucLCase;
|
|
F_CollStreamPos savedRPos;
|
|
F_CollStreamPos savedLPos;
|
|
F_CollStreamPos startLPos;
|
|
FLMUNICODE uLChar = 0;
|
|
FLMBOOL bLCharIsWild = FALSE;
|
|
FLMUNICODE uRChar = 0;
|
|
FLMBOOL bRCharIsWild = FALSE;
|
|
FLMBOOL bPrevLWasWild = FALSE;
|
|
FLMBOOL bPrevRWasWild = FALSE;
|
|
FLMBOOL bAllowTwoIntoOne;
|
|
|
|
// If we are doing a "match" operation, we don't want two
|
|
// character sequences like Ch, ae, etc. turned into a single
|
|
// a single collation, because then matches that involve wildcards
|
|
// like "aetna == a*" would not match properly.
|
|
// When not doing a match operation, we WANT two character sequences
|
|
// turned into a single collation value so that we can know if
|
|
// something is > or <. When doing match operations, all we care
|
|
// about is if they are equal or not, so there is no need to look
|
|
// at double character collation properties.
|
|
|
|
bAllowTwoIntoOne = bOpIsMatch ? FALSE : TRUE;
|
|
|
|
for( ;;)
|
|
{
|
|
GetNextLChar:
|
|
|
|
if( bLCharIsWild)
|
|
{
|
|
bPrevLWasWild = TRUE;
|
|
}
|
|
|
|
pLStream->getCurrPosition( &startLPos);
|
|
if( RC_BAD( rc = pLStream->read(
|
|
bAllowTwoIntoOne,
|
|
&uLChar, &bLCharIsWild, &ui16LCol, &ui16LSubCol, &ucLCase)))
|
|
{
|
|
if( rc == NE_XFLM_EOF_HIT)
|
|
{
|
|
rc = NE_XFLM_OK;
|
|
|
|
// If the last character was a wildcard, we have a match!
|
|
|
|
if( bPrevLWasWild)
|
|
{
|
|
*piResult = 0;
|
|
goto Exit;
|
|
}
|
|
|
|
for( ;;)
|
|
{
|
|
if( RC_BAD( rc = pRStream->read(
|
|
bAllowTwoIntoOne,
|
|
&uRChar, &bRCharIsWild, &ui16RCol, &ui16RSubCol, &ucRCase)))
|
|
{
|
|
if( rc == NE_XFLM_EOF_HIT)
|
|
{
|
|
rc = NE_XFLM_OK;
|
|
*piResult = 0;
|
|
}
|
|
|
|
goto Exit;
|
|
}
|
|
|
|
// Break out when we hit a non-wild character
|
|
|
|
if( !bRCharIsWild)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
*piResult = -1;
|
|
}
|
|
|
|
goto Exit;
|
|
}
|
|
|
|
if( bLCharIsWild)
|
|
{
|
|
// Consume multiple wildcards
|
|
|
|
if( bPrevLWasWild)
|
|
{
|
|
goto GetNextLChar;
|
|
}
|
|
|
|
// See if we match anywhere on the remaining right string
|
|
|
|
for( ;;)
|
|
{
|
|
pRStream->getCurrPosition( &savedRPos);
|
|
pLStream->getCurrPosition( &savedLPos);
|
|
|
|
if( RC_BAD( rc = fqCompareCollStreams( pLStream, pRStream,
|
|
bOpIsMatch, uiLanguage, piResult)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( !(*piResult))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( RC_BAD( rc = pRStream->positionTo( &savedRPos)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( RC_BAD( rc = pRStream->read(
|
|
bAllowTwoIntoOne,
|
|
NULL, NULL, NULL, NULL, NULL)))
|
|
{
|
|
if( rc == NE_XFLM_EOF_HIT)
|
|
{
|
|
rc = NE_XFLM_OK;
|
|
break;
|
|
}
|
|
goto Exit;
|
|
}
|
|
|
|
if( RC_BAD( rc = pLStream->positionTo( &savedLPos)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
}
|
|
|
|
*piResult = 1;
|
|
goto Exit;
|
|
}
|
|
|
|
GetNextRChar:
|
|
|
|
if( bRCharIsWild)
|
|
{
|
|
bPrevRWasWild = TRUE;
|
|
}
|
|
|
|
if( RC_BAD( rc = pRStream->read(
|
|
bAllowTwoIntoOne,
|
|
&uRChar, &bRCharIsWild, &ui16RCol, &ui16RSubCol, &ucRCase)))
|
|
{
|
|
if( rc == NE_XFLM_EOF_HIT)
|
|
{
|
|
rc = NE_XFLM_OK;
|
|
|
|
// If the last character was a wildcard, we have a match!
|
|
|
|
if( bPrevRWasWild)
|
|
{
|
|
*piResult = 0;
|
|
}
|
|
else
|
|
{
|
|
*piResult = 1;
|
|
}
|
|
}
|
|
|
|
goto Exit;
|
|
}
|
|
|
|
if( bRCharIsWild)
|
|
{
|
|
if( bPrevRWasWild)
|
|
{
|
|
goto GetNextRChar;
|
|
}
|
|
|
|
// See if we match anywhere on the remaining left string
|
|
|
|
if( RC_BAD( rc = pLStream->positionTo( &startLPos)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
for( ;;)
|
|
{
|
|
pLStream->getCurrPosition( &savedLPos);
|
|
pRStream->getCurrPosition( &savedRPos);
|
|
|
|
if( RC_BAD( rc = fqCompareCollStreams( pLStream, pRStream,
|
|
bOpIsMatch, uiLanguage, piResult)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( !(*piResult))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( RC_BAD( rc = pRStream->positionTo( &savedRPos)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( RC_BAD( rc = pLStream->positionTo( &savedLPos)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
// Skip the character we just processed
|
|
|
|
if( RC_BAD( rc = pLStream->read(
|
|
bAllowTwoIntoOne,
|
|
NULL, NULL, NULL, NULL, NULL)))
|
|
{
|
|
if( rc == NE_XFLM_EOF_HIT)
|
|
{
|
|
rc = NE_XFLM_OK;
|
|
break;
|
|
}
|
|
goto Exit;
|
|
}
|
|
}
|
|
|
|
*piResult = -1;
|
|
goto Exit;
|
|
}
|
|
|
|
if( ui16LCol != ui16RCol)
|
|
{
|
|
*piResult = ui16LCol < ui16RCol ? -1 : 1;
|
|
goto Exit;
|
|
}
|
|
else if( ui16LSubCol != ui16RSubCol)
|
|
{
|
|
*piResult = ui16LSubCol < ui16RSubCol ? -1 : 1;
|
|
goto Exit;
|
|
}
|
|
else if( ucLCase != ucRCase)
|
|
{
|
|
// NOTE: If we are doing a case insensitive comparison,
|
|
// ucLCase and ucRCase should be equal (both will have been
|
|
// set to zero
|
|
|
|
*piResult = ucLCase < ucRCase ? -1 : 1;
|
|
goto Exit;
|
|
}
|
|
}
|
|
|
|
Exit:
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Compare two entire strings.
|
|
****************************************************************************/
|
|
FSTATIC RCODE fqCompareText(
|
|
IF_OperandComparer * pOpComparer,
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FLMUINT uiCompareRules,
|
|
FLMBOOL bOpIsMatch,
|
|
FLMUINT uiLanguage,
|
|
FLMINT * piResult)
|
|
{
|
|
RCODE rc = NE_XFLM_OK;
|
|
F_BufferIStream bufferLStream;
|
|
IF_PosIStream * pLStream;
|
|
F_BufferIStream bufferRStream;
|
|
IF_PosIStream * pRStream;
|
|
F_CollIStream lStream;
|
|
F_CollIStream rStream;
|
|
|
|
// Types must be text
|
|
|
|
if (pLValue->eValType != XFLM_UTF8_VAL ||
|
|
pRValue->eValType != XFLM_UTF8_VAL)
|
|
{
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_NOT_IMPLEMENTED);
|
|
goto Exit;
|
|
}
|
|
|
|
// Open the streams
|
|
|
|
if( !(pLValue->uiFlags & VAL_IS_STREAM))
|
|
{
|
|
if (RC_BAD( rc = bufferLStream.open( pLValue->val.pucBuf,
|
|
pLValue->uiDataLen)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
pLStream = &bufferLStream;
|
|
}
|
|
else
|
|
{
|
|
pLStream = pLValue->val.pIStream;
|
|
}
|
|
|
|
if( !(pRValue->uiFlags & VAL_IS_STREAM))
|
|
{
|
|
if( RC_BAD( rc = bufferRStream.open( pRValue->val.pucBuf,
|
|
pRValue->uiDataLen)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
pRStream = &bufferRStream;
|
|
}
|
|
else
|
|
{
|
|
pRStream = pRValue->val.pIStream;
|
|
}
|
|
|
|
if (pOpComparer)
|
|
{
|
|
rc = pOpComparer->compare( pLStream, pRStream, piResult);
|
|
goto Exit;
|
|
}
|
|
|
|
// Open up the collated streams
|
|
|
|
if (RC_BAD( rc = lStream.open( pLStream, FALSE, uiLanguage, uiCompareRules,
|
|
(bOpIsMatch && (pLValue->uiFlags & VAL_IS_CONSTANT)) ? TRUE : FALSE)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if (RC_BAD( rc = rStream.open( pRStream, FALSE, uiLanguage, uiCompareRules,
|
|
(bOpIsMatch && (pRValue->uiFlags & VAL_IS_CONSTANT)) ? TRUE : FALSE)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if (RC_BAD( rc = fqCompareCollStreams( &lStream, &rStream,
|
|
bOpIsMatch, uiLanguage, piResult)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
Exit:
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Approximate compare - only works for strings right now.
|
|
****************************************************************************/
|
|
FSTATIC RCODE fqApproxCompare(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FLMINT * piResult)
|
|
{
|
|
RCODE rc = NE_XFLM_OK;
|
|
FLMUINT uiLMeta;
|
|
FLMUINT uiRMeta;
|
|
FLMUINT64 ui64StartPos;
|
|
F_BufferIStream bufferLStream;
|
|
IF_PosIStream * pLStream;
|
|
F_BufferIStream bufferRStream;
|
|
IF_PosIStream * pRStream;
|
|
|
|
// Types must be text
|
|
|
|
if (pLValue->eValType != XFLM_UTF8_VAL ||
|
|
pRValue->eValType != XFLM_UTF8_VAL)
|
|
{
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_NOT_IMPLEMENTED);
|
|
goto Exit;
|
|
}
|
|
|
|
// Open the streams
|
|
|
|
if (!(pLValue->uiFlags & VAL_IS_STREAM))
|
|
{
|
|
if (RC_BAD( rc = bufferLStream.open( pLValue->val.pucBuf,
|
|
pLValue->uiDataLen)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
pLStream = &bufferLStream;
|
|
}
|
|
else
|
|
{
|
|
pLStream = pLValue->val.pIStream;
|
|
}
|
|
|
|
if (!(pRValue->uiFlags & VAL_IS_STREAM))
|
|
{
|
|
if( RC_BAD( rc = bufferRStream.open( pRValue->val.pucBuf,
|
|
pRValue->uiDataLen)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
pRStream = &bufferRStream;
|
|
}
|
|
else
|
|
{
|
|
pRStream = pRValue->val.pIStream;
|
|
}
|
|
|
|
if ((pLValue->uiFlags & VAL_IS_CONSTANT) ||
|
|
!(pRValue->uiFlags & VAL_IS_CONSTANT))
|
|
{
|
|
for( ;;)
|
|
{
|
|
if( RC_BAD( rc = flmGetNextMetaphone( pLStream, &uiLMeta)))
|
|
{
|
|
if( rc == NE_XFLM_EOF_HIT)
|
|
{
|
|
*piResult = 0;
|
|
rc = NE_XFLM_OK;
|
|
}
|
|
goto Exit;
|
|
}
|
|
|
|
ui64StartPos = pRStream->getCurrPosition();
|
|
|
|
for( ;;)
|
|
{
|
|
if( RC_BAD( rc = flmGetNextMetaphone( pRStream, &uiRMeta)))
|
|
{
|
|
if( rc == NE_XFLM_EOF_HIT)
|
|
{
|
|
rc = NE_XFLM_OK;
|
|
*piResult = -1;
|
|
}
|
|
|
|
goto Exit;
|
|
}
|
|
|
|
if( uiLMeta == uiRMeta)
|
|
{
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
if( RC_BAD( rc = pRStream->positionTo( ui64StartPos)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for( ;;)
|
|
{
|
|
if( RC_BAD( rc = flmGetNextMetaphone( pRStream, &uiRMeta)))
|
|
{
|
|
if( rc == NE_XFLM_EOF_HIT)
|
|
{
|
|
*piResult = 0;
|
|
rc = NE_XFLM_OK;
|
|
}
|
|
goto Exit;
|
|
}
|
|
|
|
ui64StartPos = pLStream->getCurrPosition();
|
|
|
|
for( ;;)
|
|
{
|
|
if( RC_BAD( rc = flmGetNextMetaphone( pLStream, &uiLMeta)))
|
|
{
|
|
if( rc == NE_XFLM_EOF_HIT)
|
|
{
|
|
rc = NE_XFLM_OK;
|
|
*piResult = 1;
|
|
}
|
|
|
|
goto Exit;
|
|
}
|
|
|
|
if( uiLMeta == uiRMeta)
|
|
{
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
if( RC_BAD( rc = pLStream->positionTo( ui64StartPos)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
}
|
|
}
|
|
|
|
Exit:
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Performs binary comparison on two streams - may be text or binary,
|
|
it really doesn't matter. Returns XFLM_TRUE or XFLM_FALSE.
|
|
***************************************************************************/
|
|
FSTATIC RCODE fqCompareBinary(
|
|
IF_OperandComparer * pOpComparer,
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
FLMINT * piResult)
|
|
{
|
|
RCODE rc = NE_XFLM_OK;
|
|
F_BufferIStream bufferLStream;
|
|
IF_PosIStream * pLStream;
|
|
F_BufferIStream bufferRStream;
|
|
IF_PosIStream * pRStream;
|
|
FLMBYTE ucLByte;
|
|
FLMBYTE ucRByte;
|
|
FLMUINT uiOffset = 0;
|
|
FLMBOOL bLEmpty = FALSE;
|
|
|
|
*piResult = 0;
|
|
|
|
// Types must be binary
|
|
|
|
if ( pLValue->eValType != XFLM_BINARY_VAL ||
|
|
pRValue->eValType != XFLM_BINARY_VAL)
|
|
{
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_NOT_IMPLEMENTED);
|
|
goto Exit;
|
|
}
|
|
|
|
// Open the streams
|
|
|
|
if( !(pLValue->uiFlags & VAL_IS_STREAM))
|
|
{
|
|
if (RC_BAD( rc = bufferLStream.open( pLValue->val.pucBuf,
|
|
pLValue->uiDataLen)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
pLStream = &bufferLStream;
|
|
}
|
|
else
|
|
{
|
|
pLStream = pLValue->val.pIStream;
|
|
}
|
|
|
|
if( !(pRValue->uiFlags & VAL_IS_STREAM))
|
|
{
|
|
if( RC_BAD( rc = bufferRStream.open( pRValue->val.pucBuf,
|
|
pRValue->uiDataLen)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
pRStream = &bufferRStream;
|
|
}
|
|
else
|
|
{
|
|
pRStream = pRValue->val.pIStream;
|
|
}
|
|
|
|
if (pOpComparer)
|
|
{
|
|
rc = pOpComparer->compare( pLStream, pRStream, piResult);
|
|
goto Exit;
|
|
}
|
|
|
|
for (;;)
|
|
{
|
|
if (RC_BAD( rc = flmReadStorageAsBinary(
|
|
pLStream, &ucLByte, 1, uiOffset, NULL)))
|
|
{
|
|
if (rc == NE_XFLM_EOF_HIT)
|
|
{
|
|
rc = NE_XFLM_OK;
|
|
bLEmpty = TRUE;
|
|
}
|
|
else
|
|
{
|
|
goto Exit;
|
|
}
|
|
}
|
|
|
|
if (RC_BAD( rc = flmReadStorageAsBinary(
|
|
pRStream, &ucRByte, 1, uiOffset, NULL)))
|
|
{
|
|
if (rc == NE_XFLM_EOF_HIT)
|
|
{
|
|
rc = NE_XFLM_OK;
|
|
if( bLEmpty)
|
|
{
|
|
*piResult = 0;
|
|
}
|
|
else
|
|
{
|
|
*piResult = 1;
|
|
}
|
|
}
|
|
goto Exit;
|
|
}
|
|
else if( bLEmpty)
|
|
{
|
|
*piResult = -1;
|
|
goto Exit;
|
|
}
|
|
|
|
if( ucLByte != ucRByte)
|
|
{
|
|
*piResult = ucLByte < ucRByte ? -1 : 1;
|
|
goto Exit;
|
|
}
|
|
|
|
uiOffset++;
|
|
}
|
|
|
|
Exit:
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Compare two values. This routine assumes that pValue1 and pValue2
|
|
are non-null.
|
|
***************************************************************************/
|
|
RCODE fqCompare(
|
|
FQVALUE * pValue1,
|
|
FQVALUE * pValue2,
|
|
FLMUINT uiCompareRules,
|
|
IF_OperandComparer * pOpComparer,
|
|
FLMUINT uiLanguage,
|
|
FLMINT * piCmp)
|
|
{
|
|
RCODE rc = NE_XFLM_OK;
|
|
|
|
// We have already called fqCanCompare, so no need to do it here
|
|
|
|
switch (pValue1->eValType)
|
|
{
|
|
case XFLM_BOOL_VAL:
|
|
*piCmp = pValue1->val.eBool > pValue2->val.eBool
|
|
? 1
|
|
: pValue1->val.eBool < pValue2->val.eBool
|
|
? -1
|
|
: 0;
|
|
break;
|
|
case XFLM_UINT_VAL:
|
|
switch (pValue2->eValType)
|
|
{
|
|
case XFLM_UINT_VAL:
|
|
*piCmp = pValue1->val.uiVal > pValue2->val.uiVal
|
|
? 1
|
|
: pValue1->val.uiVal < pValue2->val.uiVal
|
|
? -1
|
|
: 0;
|
|
break;
|
|
case XFLM_UINT64_VAL:
|
|
*piCmp = (FLMUINT64)pValue1->val.uiVal > pValue2->val.ui64Val
|
|
? 1
|
|
: (FLMUINT64)pValue1->val.uiVal < pValue2->val.ui64Val
|
|
? -1
|
|
: 0;
|
|
break;
|
|
case XFLM_INT_VAL:
|
|
*piCmp = pValue2->val.iVal < 0 ||
|
|
pValue1->val.uiVal > (FLMUINT)pValue2->val.iVal
|
|
? 1
|
|
: pValue1->val.uiVal < (FLMUINT)pValue2->val.iVal
|
|
? -1
|
|
: 0;
|
|
break;
|
|
case XFLM_INT64_VAL:
|
|
*piCmp = pValue2->val.i64Val < 0 ||
|
|
(FLMUINT64)pValue1->val.uiVal >
|
|
(FLMUINT64)pValue2->val.i64Val
|
|
? 1
|
|
: (FLMUINT64)pValue1->val.uiVal <
|
|
(FLMUINT64)pValue2->val.i64Val
|
|
? -1
|
|
: 0;
|
|
break;
|
|
default:
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_NOT_IMPLEMENTED);
|
|
goto Exit;
|
|
}
|
|
break;
|
|
case XFLM_UINT64_VAL:
|
|
switch (pValue2->eValType)
|
|
{
|
|
case XFLM_UINT_VAL:
|
|
*piCmp = pValue1->val.ui64Val > (FLMUINT64)pValue2->val.uiVal
|
|
? 1
|
|
: pValue1->val.ui64Val < (FLMUINT64)pValue2->val.uiVal
|
|
? -1
|
|
: 0;
|
|
break;
|
|
case XFLM_UINT64_VAL:
|
|
*piCmp = pValue1->val.ui64Val > pValue2->val.ui64Val
|
|
? 1
|
|
: pValue1->val.ui64Val < pValue2->val.ui64Val
|
|
? -1
|
|
: 0;
|
|
break;
|
|
case XFLM_INT_VAL:
|
|
*piCmp = pValue2->val.iVal < 0 ||
|
|
pValue1->val.ui64Val > (FLMUINT64)pValue2->val.iVal
|
|
? 1
|
|
: pValue1->val.ui64Val < (FLMUINT64)pValue2->val.iVal
|
|
? -1
|
|
: 0;
|
|
break;
|
|
case XFLM_INT64_VAL:
|
|
*piCmp = pValue2->val.i64Val < 0 ||
|
|
pValue1->val.ui64Val > (FLMUINT64)pValue2->val.i64Val
|
|
? 1
|
|
: pValue1->val.ui64Val < (FLMUINT64)pValue2->val.i64Val
|
|
? -1
|
|
: 0;
|
|
break;
|
|
default:
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_NOT_IMPLEMENTED);
|
|
goto Exit;
|
|
}
|
|
break;
|
|
case XFLM_INT_VAL:
|
|
switch (pValue2->eValType)
|
|
{
|
|
case XFLM_UINT_VAL:
|
|
*piCmp = pValue1->val.iVal < 0 ||
|
|
(FLMUINT)pValue1->val.iVal < pValue2->val.uiVal
|
|
? -1
|
|
: (FLMUINT)pValue1->val.iVal > pValue2->val.uiVal
|
|
? 1
|
|
: 0;
|
|
break;
|
|
case XFLM_UINT64_VAL:
|
|
*piCmp = pValue1->val.iVal < 0 ||
|
|
(FLMUINT64)pValue1->val.iVal < pValue2->val.ui64Val
|
|
? -1
|
|
: (FLMUINT64)pValue1->val.iVal > pValue2->val.ui64Val
|
|
? 1
|
|
: 0;
|
|
break;
|
|
case XFLM_INT_VAL:
|
|
*piCmp = pValue1->val.iVal < pValue2->val.iVal
|
|
? -1
|
|
: pValue1->val.iVal > pValue2->val.iVal
|
|
? 1
|
|
: 0;
|
|
break;
|
|
case XFLM_INT64_VAL:
|
|
*piCmp = (FLMINT64)pValue1->val.iVal < pValue2->val.i64Val
|
|
? -1
|
|
: (FLMINT64)pValue1->val.iVal > pValue2->val.i64Val
|
|
? 1
|
|
: 0;
|
|
break;
|
|
default:
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_NOT_IMPLEMENTED);
|
|
goto Exit;
|
|
}
|
|
break;
|
|
case XFLM_INT64_VAL:
|
|
switch (pValue2->eValType)
|
|
{
|
|
case XFLM_UINT_VAL:
|
|
*piCmp = pValue1->val.i64Val < 0 ||
|
|
(FLMUINT64)pValue1->val.i64Val <
|
|
(FLMUINT64)pValue2->val.uiVal
|
|
? -1
|
|
: (FLMUINT64)pValue1->val.i64Val >
|
|
(FLMUINT64)pValue2->val.uiVal
|
|
? 1
|
|
: 0;
|
|
break;
|
|
case XFLM_UINT64_VAL:
|
|
*piCmp = pValue1->val.i64Val < 0 ||
|
|
(FLMUINT64)pValue1->val.i64Val < pValue2->val.ui64Val
|
|
? -1
|
|
: (FLMUINT64)pValue1->val.i64Val > pValue2->val.ui64Val
|
|
? 1
|
|
: 0;
|
|
break;
|
|
case XFLM_INT_VAL:
|
|
*piCmp = pValue1->val.i64Val < (FLMINT64)pValue2->val.iVal
|
|
? -1
|
|
: pValue1->val.i64Val > (FLMINT64)pValue2->val.iVal
|
|
? 1
|
|
: 0;
|
|
break;
|
|
case XFLM_INT64_VAL:
|
|
*piCmp = pValue1->val.i64Val < pValue2->val.i64Val
|
|
? -1
|
|
: pValue1->val.i64Val > pValue2->val.i64Val
|
|
? 1
|
|
: 0;
|
|
break;
|
|
default:
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_NOT_IMPLEMENTED);
|
|
goto Exit;
|
|
}
|
|
break;
|
|
case XFLM_BINARY_VAL:
|
|
if (RC_BAD( rc = fqCompareBinary( pOpComparer, pValue1,
|
|
pValue2, piCmp)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
break;
|
|
case XFLM_UTF8_VAL:
|
|
if (RC_BAD( rc = fqCompareText( pOpComparer,
|
|
pValue1, pValue2,
|
|
uiCompareRules, FALSE, uiLanguage, piCmp)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
Exit:
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Do a comparison operator.
|
|
***************************************************************************/
|
|
RCODE fqCompareOperands(
|
|
FLMUINT uiLanguage,
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
eQueryOperators eOperator,
|
|
FLMUINT uiCompareRules,
|
|
IF_OperandComparer * pOpComparer,
|
|
FLMBOOL bNotted,
|
|
XFlmBoolType * peBool)
|
|
{
|
|
RCODE rc = NE_XFLM_OK;
|
|
FLMINT iCmp;
|
|
|
|
if (!pLValue || pLValue->eValType == XFLM_MISSING_VAL ||
|
|
!pRValue || pRValue->eValType == XFLM_MISSING_VAL ||
|
|
!fqCanCompare( pLValue, pRValue))
|
|
{
|
|
*peBool = (bNotted ? XFLM_TRUE : XFLM_FALSE);
|
|
}
|
|
|
|
// At this point, both operands are known to be present and are of
|
|
// types that can be compared. The comparison
|
|
// will therefore be performed according to the
|
|
// operator specified.
|
|
|
|
else
|
|
{
|
|
switch (eOperator)
|
|
{
|
|
case XFLM_EQ_OP:
|
|
case XFLM_NE_OP:
|
|
if (pLValue->eValType == XFLM_UTF8_VAL ||
|
|
pRValue->eValType == XFLM_UTF8_VAL)
|
|
{
|
|
if (RC_BAD( rc = fqCompareText( pOpComparer, pLValue, pRValue,
|
|
uiCompareRules, TRUE, uiLanguage, &iCmp)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (RC_BAD( rc = fqCompare( pLValue, pRValue,
|
|
uiCompareRules, pOpComparer, uiLanguage, &iCmp)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
}
|
|
if (eOperator == XFLM_EQ_OP)
|
|
{
|
|
*peBool = (iCmp == 0 ? XFLM_TRUE : XFLM_FALSE);
|
|
}
|
|
else
|
|
{
|
|
*peBool = (iCmp != 0 ? XFLM_TRUE : XFLM_FALSE);
|
|
}
|
|
break;
|
|
|
|
case XFLM_APPROX_EQ_OP:
|
|
if (RC_BAD( rc = fqApproxCompare( pLValue, pRValue, &iCmp)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
*peBool = (iCmp == 0 ? XFLM_TRUE : XFLM_FALSE);
|
|
break;
|
|
|
|
case XFLM_LT_OP:
|
|
if (RC_BAD( rc = fqCompare( pLValue, pRValue,
|
|
uiCompareRules, pOpComparer, uiLanguage, &iCmp)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
*peBool = (iCmp < 0 ? XFLM_TRUE : XFLM_FALSE);
|
|
break;
|
|
|
|
case XFLM_LE_OP:
|
|
if (RC_BAD( rc = fqCompare( pLValue, pRValue,
|
|
uiCompareRules, pOpComparer, uiLanguage, &iCmp)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
*peBool = (iCmp <= 0 ? XFLM_TRUE : XFLM_FALSE);
|
|
break;
|
|
|
|
case XFLM_GT_OP:
|
|
if (RC_BAD( rc = fqCompare( pLValue, pRValue,
|
|
uiCompareRules, pOpComparer, uiLanguage, &iCmp)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
*peBool = (iCmp > 0 ? XFLM_TRUE : XFLM_FALSE);
|
|
break;
|
|
|
|
case XFLM_GE_OP:
|
|
if (RC_BAD( rc = fqCompare( pLValue, pRValue,
|
|
uiCompareRules, pOpComparer, uiLanguage, &iCmp)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
*peBool = (iCmp >= 0 ? XFLM_TRUE : XFLM_FALSE);
|
|
break;
|
|
|
|
default:
|
|
*peBool = XFLM_UNKNOWN;
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_QUERY_SYNTAX);
|
|
goto Exit;
|
|
}
|
|
}
|
|
|
|
Exit:
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc: Do an arithmetic operator.
|
|
***************************************************************************/
|
|
RCODE fqArithmeticOperator(
|
|
FQVALUE * pLValue,
|
|
FQVALUE * pRValue,
|
|
eQueryOperators eOperator,
|
|
FQVALUE * pResult)
|
|
{
|
|
RCODE rc = NE_XFLM_OK;
|
|
FQ_OPERATION * fnOp;
|
|
FLMUINT uiOffset = 0;
|
|
|
|
if( !isArithOp( eOperator))
|
|
{
|
|
rc = RC_SET( NE_XFLM_SYNTAX);
|
|
goto Exit;
|
|
}
|
|
|
|
if (pLValue->eValType == XFLM_MISSING_VAL ||
|
|
pRValue->eValType == XFLM_MISSING_VAL)
|
|
{
|
|
pResult->eValType = XFLM_MISSING_VAL;
|
|
goto Exit;
|
|
}
|
|
|
|
if( isUnsigned( pLValue))
|
|
{
|
|
if( isUnsigned( pRValue))
|
|
{
|
|
uiOffset = 0;
|
|
}
|
|
else if( isSigned( pRValue))
|
|
{
|
|
uiOffset = 1;
|
|
}
|
|
else
|
|
{
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_NOT_IMPLEMENTED);
|
|
goto Exit;
|
|
}
|
|
}
|
|
else if( isSigned( pLValue))
|
|
{
|
|
if( isUnsigned( pRValue))
|
|
{
|
|
uiOffset = 2;
|
|
}
|
|
else if( isSigned( pRValue))
|
|
{
|
|
uiOffset = 3;
|
|
}
|
|
else
|
|
{
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_NOT_IMPLEMENTED);
|
|
goto Exit;
|
|
}
|
|
}
|
|
|
|
fnOp = FQ_ArithOpTable[ ((((FLMUINT)eOperator) -
|
|
XFLM_FIRST_ARITH_OP) * 4) + uiOffset];
|
|
fnOp( pLValue, pRValue, pResult);
|
|
|
|
Exit:
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
Desc:
|
|
******************************************************************************/
|
|
RCODE F_CollIStream::read(
|
|
FLMBOOL bAllowTwoIntoOne,
|
|
FLMUNICODE * puChar,
|
|
FLMBOOL * pbCharIsWild,
|
|
FLMUINT16 * pui16Col,
|
|
FLMUINT16 * pui16SubCol,
|
|
FLMBYTE * pucCase)
|
|
{
|
|
RCODE rc = NE_XFLM_OK;
|
|
FLMUNICODE uChar;
|
|
FLMUINT16 ui16WpChar;
|
|
FLMUINT16 ui16NextWpChar;
|
|
FLMUINT16 ui16Col;
|
|
FLMUINT16 ui16SubCol;
|
|
FLMBOOL bTwoIntoOne;
|
|
FLMBYTE ucCase;
|
|
FLMBOOL bAsian;
|
|
FLMBOOL bLastCharWasSpace = FALSE;
|
|
FLMUINT64 ui64AfterLastSpacePos = 0;
|
|
FLMUINT64 ui64CurrCharPos = 0;
|
|
|
|
if (pbCharIsWild)
|
|
{
|
|
*pbCharIsWild = FALSE;
|
|
}
|
|
|
|
// Is this a double-byte (Asian) character set?
|
|
|
|
bAsian = (m_uiLanguage >= FIRST_DBCS_LANG && m_uiLanguage <= LAST_DBCS_LANG)
|
|
? TRUE
|
|
: FALSE;
|
|
|
|
// Get the next character from the stream
|
|
|
|
GetNextChar:
|
|
|
|
ui16WpChar = 0;
|
|
ui16NextWpChar = 0;
|
|
ui16Col = 0;
|
|
ui16SubCol = 0;
|
|
bTwoIntoOne = FALSE;
|
|
ucCase = 0;
|
|
|
|
if (m_uNextChar)
|
|
{
|
|
uChar = m_uNextChar;
|
|
m_uNextChar = 0;
|
|
}
|
|
else
|
|
{
|
|
ui64CurrCharPos = m_pIStream->getCurrPosition();
|
|
if( RC_BAD( rc = readCharFromStream( &uChar)))
|
|
{
|
|
if (rc != NE_XFLM_EOF_HIT)
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
// If we were skipping spaces, we need to
|
|
// process a single space character, unless we are
|
|
// ignoring trailing white space.
|
|
|
|
if (bLastCharWasSpace &&
|
|
!(m_uiCompareRules & XFLM_COMP_IGNORE_TRAILING_SPACE))
|
|
{
|
|
// bLastCharWasSpace flag can only be TRUE if either
|
|
// XFLM_COMP_IGNORE_TRAILING_SPACE is set or
|
|
// XFLM_COMP_COMPRESS_WHITESPACE is set.
|
|
|
|
flmAssert( m_uiCompareRules & XFLM_COMP_COMPRESS_WHITESPACE);
|
|
uChar = ASCII_SPACE;
|
|
rc = NE_XFLM_OK;
|
|
goto Process_Char;
|
|
}
|
|
goto Exit;
|
|
}
|
|
}
|
|
|
|
if ((uChar = flmConvertChar( uChar, m_uiCompareRules)) == 0)
|
|
{
|
|
goto GetNextChar;
|
|
}
|
|
|
|
// Deal with spaces
|
|
|
|
if (uChar == ASCII_SPACE)
|
|
{
|
|
if (m_uiCompareRules & XFLM_COMP_COMPRESS_WHITESPACE)
|
|
{
|
|
bLastCharWasSpace = TRUE;
|
|
ui64AfterLastSpacePos = m_pIStream->getCurrPosition();
|
|
goto GetNextChar;
|
|
}
|
|
else if (m_uiCompareRules & XFLM_COMP_IGNORE_TRAILING_SPACE)
|
|
{
|
|
if (!bLastCharWasSpace)
|
|
{
|
|
bLastCharWasSpace = TRUE;
|
|
|
|
// Save where we are at so that if this doesn't turn out
|
|
// to be trailing spaces, we can restore this position.
|
|
|
|
ui64AfterLastSpacePos = m_pIStream->getCurrPosition();
|
|
}
|
|
goto GetNextChar;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_uiCompareRules & XFLM_COMP_IGNORE_LEADING_SPACE)
|
|
{
|
|
m_ui64EndOfLeadingSpacesPos = ui64CurrCharPos;
|
|
m_uiCompareRules &= (~(XFLM_COMP_IGNORE_LEADING_SPACE));
|
|
}
|
|
|
|
// If the last character was a space, we need to process it.
|
|
|
|
if (bLastCharWasSpace)
|
|
{
|
|
|
|
// Position back to after the last space, and process a space
|
|
// character.
|
|
|
|
if (RC_BAD( rc = m_pIStream->positionTo( ui64AfterLastSpacePos)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
uChar = ASCII_SPACE;
|
|
bLastCharWasSpace = FALSE;
|
|
}
|
|
else if (uChar == ASCII_BACKSLASH)
|
|
{
|
|
// If wildcards are allowed, the backslash should be treated
|
|
// as an escape character, and the next character is the one
|
|
// we want. Otherwise, it should be treated as
|
|
// the actual character we want returned.
|
|
|
|
if (m_bMayHaveWildCards)
|
|
{
|
|
|
|
// Got a backslash. Means the next character is to be taken
|
|
// no matter what because it is escaped.
|
|
|
|
if (RC_BAD( rc = readCharFromStream( &uChar)))
|
|
{
|
|
if (rc != NE_XFLM_EOF_HIT)
|
|
{
|
|
goto Exit;
|
|
}
|
|
rc = NE_XFLM_OK;
|
|
uChar = ASCII_BACKSLASH;
|
|
}
|
|
}
|
|
}
|
|
else if (uChar == ASCII_WILDCARD)
|
|
{
|
|
if (m_bMayHaveWildCards && pbCharIsWild)
|
|
{
|
|
*pbCharIsWild = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
Process_Char:
|
|
|
|
if (!bAsian)
|
|
{
|
|
|
|
// Must check for double characters if non-US and non-Asian
|
|
// character set
|
|
|
|
if (m_uiLanguage != XFLM_US_LANG)
|
|
{
|
|
if (RC_BAD( rc = flmWPCheckDoubleCollation(
|
|
m_pIStream, m_bUnicodeStream, bAllowTwoIntoOne,
|
|
&uChar, &m_uNextChar, &bTwoIntoOne, m_uiLanguage)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (RC_BAD( rc = readCharFromStream( &m_uNextChar)))
|
|
{
|
|
if (rc == NE_XFLM_EOF_HIT)
|
|
{
|
|
rc = NE_XFLM_OK;
|
|
m_uNextChar = 0;
|
|
}
|
|
else
|
|
{
|
|
RC_UNEXPECTED_ASSERT( rc);
|
|
goto Exit;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Convert each character to its WP equivalent
|
|
|
|
if (!flmUnicodeToWP( uChar, &ui16WpChar))
|
|
{
|
|
ui16WpChar = 0;
|
|
}
|
|
|
|
if (!flmUnicodeToWP( m_uNextChar, &ui16NextWpChar))
|
|
{
|
|
ui16NextWpChar = 0;
|
|
}
|
|
|
|
// If we have an unconvertible UNICODE character, the collation
|
|
// value for it will be COLS0
|
|
|
|
if (!ui16WpChar)
|
|
{
|
|
if (!bAsian)
|
|
{
|
|
ui16Col = COLS0;
|
|
}
|
|
else
|
|
{
|
|
if (uChar < 0x20)
|
|
{
|
|
ui16Col = 0xFFFF;
|
|
ui16SubCol = uChar;
|
|
}
|
|
else
|
|
{
|
|
ui16Col = uChar;
|
|
ui16SubCol = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!bAsian)
|
|
{
|
|
ui16Col = flmWPGetCollation( ui16WpChar, m_uiLanguage);
|
|
if (bTwoIntoOne)
|
|
{
|
|
// Since two characters were merged into one, increment
|
|
// the collation value by one. In the case of something
|
|
// like 'ch', there is a collation value between 'c' and
|
|
// 'd'. flmWPGetCollation would have returned the
|
|
// collation value for 'c' ... incrementing by one gives
|
|
// us the proper collation value for 'ch' (i.e., the
|
|
// collation value between 'c' and 'd').
|
|
|
|
ui16Col++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (flmWPAsiaGetCollation( ui16WpChar, ui16NextWpChar, ui16Col,
|
|
&ui16Col, &ui16SubCol, &ucCase, !m_bCaseSensitive) == 2)
|
|
{
|
|
|
|
// Next character was consumed by collation
|
|
|
|
m_uNextChar = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pui16Col)
|
|
{
|
|
*pui16Col = ui16Col;
|
|
}
|
|
|
|
// Consume m_uNextChar if two characters merged into one
|
|
|
|
if (bTwoIntoOne)
|
|
{
|
|
m_uNextChar = 0;
|
|
}
|
|
|
|
// Subcollation
|
|
|
|
if( pui16SubCol)
|
|
{
|
|
if( uChar > 127 && !bAsian)
|
|
{
|
|
ui16SubCol = ui16WpChar
|
|
? flmWPGetSubCol( ui16WpChar, ui16Col, m_uiLanguage)
|
|
: uChar;
|
|
|
|
if( !m_bCaseSensitive)
|
|
{
|
|
// If the sub-collation value is the original
|
|
// character, it means that the collation could not
|
|
// distinguish the characters and sub-collation is being
|
|
// used to do it. However, this creates a problem when the
|
|
// characters are the same character except for case. In that
|
|
// scenario, we incorrectly return a not-equal when we are
|
|
// doing a case-insensitive comparison. So, at this point,
|
|
// we need to use the sub-collation for the upper-case of the
|
|
// character instead of the sub-collation for the character
|
|
// itself.
|
|
|
|
if( ui16WpChar && ui16SubCol == ui16WpChar)
|
|
{
|
|
ui16SubCol = flmWPGetSubCol(
|
|
flmWPUpper( ui16WpChar),
|
|
ui16Col, m_uiLanguage);
|
|
}
|
|
}
|
|
}
|
|
|
|
*pui16SubCol = ui16SubCol;
|
|
}
|
|
|
|
// Case
|
|
|
|
if( pucCase)
|
|
{
|
|
if (!m_bCaseSensitive)
|
|
{
|
|
*pucCase = 0;
|
|
}
|
|
else
|
|
{
|
|
if (!bAsian && ui16WpChar)
|
|
{
|
|
// flmWPIsUpper() returns FALSE if the character is lower or
|
|
// TRUE if the character is not lower case.
|
|
|
|
if( flmWPIsUpper( ui16WpChar))
|
|
{
|
|
if( bTwoIntoOne)
|
|
{
|
|
if( flmWPIsUpper( ui16NextWpChar))
|
|
{
|
|
ucCase = 0x03;
|
|
}
|
|
else
|
|
{
|
|
ucCase = 0x10;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ucCase = 0x01;
|
|
}
|
|
}
|
|
}
|
|
*pucCase = ucCase;
|
|
}
|
|
}
|
|
|
|
if (puChar)
|
|
{
|
|
*puChar = uChar;
|
|
}
|
|
|
|
Exit:
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc:
|
|
****************************************************************************/
|
|
RCODE F_DbSystem::compareUTF8Strings(
|
|
const FLMBYTE * pucLString,
|
|
FLMUINT uiLStrBytes,
|
|
FLMBOOL bLeftWild,
|
|
const FLMBYTE * pucRString,
|
|
FLMUINT uiRStrBytes,
|
|
FLMBOOL bRightWild,
|
|
FLMUINT uiCompareRules,
|
|
FLMUINT uiLanguage,
|
|
FLMINT * piResult)
|
|
{
|
|
RCODE rc = NE_XFLM_OK;
|
|
F_BufferIStream bufferLStream;
|
|
F_BufferIStream bufferRStream;
|
|
F_CollIStream lStream;
|
|
F_CollIStream rStream;
|
|
|
|
if (RC_BAD( rc = bufferLStream.open( pucLString, uiLStrBytes)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( RC_BAD( rc = bufferRStream.open( pucRString, uiRStrBytes)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( RC_BAD( rc = lStream.open( &bufferLStream, FALSE, uiLanguage,
|
|
uiCompareRules, bLeftWild)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( RC_BAD( rc = rStream.open( &bufferRStream, FALSE, uiLanguage,
|
|
uiCompareRules, bRightWild)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( RC_BAD( rc = fqCompareCollStreams( &lStream, &rStream,
|
|
(bLeftWild || bRightWild) ? TRUE : FALSE,
|
|
uiLanguage, piResult)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
Exit:
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc:
|
|
****************************************************************************/
|
|
RCODE F_DbSystem::compareUnicodeStrings(
|
|
const FLMUNICODE * puzLString,
|
|
FLMUINT uiLStrBytes,
|
|
FLMBOOL bLeftWild,
|
|
const FLMUNICODE * puzRString,
|
|
FLMUINT uiRStrBytes,
|
|
FLMBOOL bRightWild,
|
|
FLMUINT uiCompareRules,
|
|
FLMUINT uiLanguage,
|
|
FLMINT * piResult)
|
|
{
|
|
RCODE rc = NE_XFLM_OK;
|
|
F_BufferIStream bufferLStream;
|
|
F_BufferIStream bufferRStream;
|
|
F_CollIStream lStream;
|
|
F_CollIStream rStream;
|
|
|
|
if( RC_BAD( rc = bufferLStream.open( (FLMBYTE *)puzLString, uiLStrBytes)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( RC_BAD( rc = bufferRStream.open( (FLMBYTE *)puzRString, uiRStrBytes)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( RC_BAD( rc = lStream.open( &bufferLStream, TRUE, uiLanguage,
|
|
uiCompareRules, bLeftWild)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( RC_BAD( rc = rStream.open( &bufferRStream, TRUE, uiLanguage,
|
|
uiCompareRules, bRightWild)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( RC_BAD( rc = fqCompareCollStreams( &lStream, &rStream,
|
|
(bLeftWild || bRightWild) ? TRUE : FALSE, uiLanguage, piResult)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
Exit:
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/***************************************************************************
|
|
Desc:
|
|
****************************************************************************/
|
|
RCODE XFLMAPI F_DbSystem::utf8IsSubStr(
|
|
const FLMBYTE * pszString,
|
|
const FLMBYTE * pszSubString,
|
|
FLMUINT uiCompareRules,
|
|
FLMUINT uiLanguage,
|
|
FLMBOOL * pbExists)
|
|
{
|
|
RCODE rc = NE_XFLM_OK;
|
|
FLMINT iResult = 0;
|
|
FLMBYTE * pszSearch = NULL;
|
|
FLMUINT uiSubStringLen = f_strlen( pszSubString);
|
|
|
|
if( RC_BAD( rc = f_alloc( uiSubStringLen + 3, &pszSearch)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
pszSearch[0] = '*';
|
|
f_memcpy( &pszSearch[ 1], pszSubString, uiSubStringLen);
|
|
pszSearch[ uiSubStringLen + 1] = '*';
|
|
pszSearch[ uiSubStringLen + 2] = '\0';
|
|
|
|
if( RC_BAD( rc = compareUTF8Strings(
|
|
pszString, f_strlen( pszString), FALSE, pszSearch,
|
|
uiSubStringLen + 2, TRUE, uiCompareRules, uiLanguage, &iResult)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
*pbExists = (iResult)?FALSE:TRUE;
|
|
|
|
Exit:
|
|
|
|
if( pszSearch)
|
|
{
|
|
f_free( &pszSearch);
|
|
}
|
|
|
|
return( rc);
|
|
}
|