ef0883bf02
* harbour/Makefile
+ harbour/make_bsd.sh
+ harbour/make_drw.sh
* harbour/make_tgz.sh
+ harbour/bin/hb-func.sh
* harbour/bin/pack_src.sh
+ harbour/bin/postinst.bat
+ harbour/bin/postinst.sh
* harbour/config/dir.cf
* harbour/config/bsd/gcc.cf
* harbour/config/bsd/global.cf
+ harbour/config/darwin/dir.cf
+ harbour/config/darwin/gcc.cf
+ harbour/config/darwin/global.cf
+ harbour/config/darwin/install.cf
* harbour/config/dos/dir.cf
* harbour/config/dos/global.cf
* harbour/config/dos/install.cf
* harbour/config/dos/owatcom.cf
* harbour/config/dos/watcom.cf
* harbour/config/linux/gcc.cf
* harbour/config/linux/global.cf
* harbour/contrib/Makefile
* harbour/contrib/dot/pp_harb.ch
* harbour/contrib/libct/Makefile
* harbour/contrib/libct/bit1.c
* harbour/contrib/libct/bit2.c
* harbour/contrib/libct/bit3.c
* harbour/contrib/libct/files.c
* harbour/contrib/libct/ftoc.c
- harbour/contrib/libct/invertwin.prg
+ harbour/contrib/libct/invrtwin.prg
* harbour/contrib/libct/keyset.c
* harbour/contrib/libct/makefile.bc
* harbour/contrib/libmisc/dates2.c
* harbour/contrib/rdd_ads/ads1.c
* harbour/contrib/rdd_ads/adsfunc.c
* harbour/contrib/samples/date.c
* harbour/include/dbinfo.ch
* harbour/include/hbapi.h
* harbour/include/hbapicdp.h
* harbour/include/hbapifs.h
* harbour/include/hbapigt.h
* harbour/include/hbapiitm.h
* harbour/include/hbcomp.h
* harbour/include/hbdate.h
* harbour/include/hbdbf.h
* harbour/include/hbdbferr.h
* harbour/include/hbdefs.h
* harbour/include/hbexprb.c
* harbour/include/hbexprc.c
* harbour/include/hbexprop.h
* harbour/include/hbmacro.h
* harbour/include/hbmath.h
* harbour/include/hbpcode.h
* harbour/include/hbrddcdx.h
* harbour/include/hbrdddbf.h
* harbour/include/hbrdddbt.h
* harbour/include/hbrddfpt.h
* harbour/include/hbrddntx.h
* harbour/include/hbset.h
* harbour/include/hbsetup.h
* harbour/include/set.ch
* harbour/source/common/Makefile
* harbour/source/common/expropt1.c
* harbour/source/common/expropt2.c
- harbour/source/common/hbffind.c
* harbour/source/common/hbfsapi.c
* harbour/source/common/hbstr.c
* harbour/source/common/hbver.c
+ harbour/source/common/hbverdsp.c
* harbour/source/compiler/genc.c
* harbour/source/compiler/gencli.c
* harbour/source/compiler/harbour.c
* harbour/source/compiler/harbour.l
* harbour/source/compiler/harbour.slx
* harbour/source/compiler/harbour.sly
* harbour/source/compiler/harbour.y
* harbour/source/compiler/hbfix.c
* harbour/source/compiler/hbpcode.c
* harbour/source/compiler/hbusage.c
* harbour/source/compiler/simplex.c
* harbour/source/macro/macro.l
* harbour/source/macro/macro.slx
* harbour/source/macro/macro.y
* harbour/source/pp/ppcore.c
* harbour/source/rdd/dbcmd.c
* harbour/source/rdd/dbf1.c
* harbour/source/rdd/dbfcdx/dbfcdx1.c
- harbour/source/rdd/dbfcdx/dbfcdx1.h
* harbour/source/rdd/dbffpt/dbffpt1.c
* harbour/source/rdd/dbfntx/dbfntx1.c
* harbour/source/rtl/Makefile
* harbour/source/rtl/abs.c
* harbour/source/rtl/at.c
* harbour/source/rtl/datec.c
* harbour/source/rtl/dates.c
* harbour/source/rtl/dateshb.c
* harbour/source/rtl/datesx.c
* harbour/source/rtl/empty.c
* harbour/source/rtl/errorapi.c
* harbour/source/rtl/errorint.c
* harbour/source/rtl/filesys.c
* harbour/source/rtl/fstemp.c
+ harbour/source/rtl/hbffind.c
* harbour/source/rtl/hbrandom.c
* harbour/source/rtl/idle.c
* harbour/source/rtl/inkey.c
* harbour/source/rtl/math.c
* harbour/source/rtl/minmax.c
* harbour/source/rtl/pad.c
* harbour/source/rtl/padc.c
* harbour/source/rtl/padl.c
* harbour/source/rtl/padr.c
* harbour/source/rtl/philes.c
* harbour/source/rtl/round.c
* harbour/source/rtl/soundex.c
* harbour/source/rtl/str.c
* harbour/source/rtl/strcase.c
* harbour/source/rtl/strmatch.c
* harbour/source/rtl/strtran.c
* harbour/source/rtl/strzero.c
* harbour/source/rtl/substr.c
* harbour/source/rtl/val.c
* harbour/source/rtl/gtcrs/gtcrs.c
* harbour/source/rtl/gtcrs/kbdcrs.c
* harbour/source/rtl/gtdos/gtdos.c
* harbour/source/rtl/gtsln/gtsln.c
* harbour/source/rtl/gtsln/kbsln.c
* harbour/source/rtl/gtsln/keytrans.c
* harbour/source/vm/arrays.c
* harbour/source/vm/codebloc.c
* harbour/source/vm/estack.c
* harbour/source/vm/eval.c
* harbour/source/vm/extend.c
* harbour/source/vm/hvm.c
* harbour/source/vm/itemapi.c
* harbour/source/vm/macro.c
* harbour/source/vm/memvars.c
* harbour/source/vm/runner.c
* harbour/tests/bldtest/bldtest.c
* harbour/utils/hbtest/hbtest.prg
* harbour/utils/hbtest/rt_misc.prg
* harbour/utils/hbtest/rt_str.prg
* Sorry but it's too much modification for full description
cvs diff gives file 785982 bytes length. So I only count the
main things:
! cleand the code (no more warning messages under Linux and GCC and
DOS OpenWatcom) - some of them were real bugs
! cleaned all endian dependend code I've found - now Harbour can be
compiled on LITLE and BIG endian machines - for some other like
PDP ENDIAN it's enough to define proper macros in hbdefs.h
+ added macros for to get/put values in chosen byte order:
HB_GET_LE_[U]INT{16,24,32,64}( pPtr )
HB_GET_BE_[U]INT{16,24,32,64}( pPtr )
HB_PUT_LE_[U]INT{16,24,32,64}( pPtr, nVal )
HB_PUT_BE_[U]INT{16,24,32,64}( pPtr, nVal )
+ added macro HB_CAST_BYTE_NUMBERS_OFF which disables casting in
HB_{GET|PUT}_{LE|BE}_* macros - it's necessary for some platforms
like ALPHA DEC.
! cleaned the code for 64bit machines
* changed all parameters in hb_date* functions (day, month, year, week)
from LONG to int - it doesn't change binary compatibility for 32bit
machines but can cause troubles with compiling the old source
+ changed HB_IT_LONG type to HB_LONG which is mapped to long long
by default for 32 bit machines.
+ change HB_IT_INTEGER to be real 'int' C type not 'short int'
+ added HB_IS_NUMINT() macro
+ added hb_parnll, hb_stornll, hb_retnll, hbretnlllen, hb_itemPutNLL,
hb_itemPutNLLLen, hb_itemGetNLL which operates on LONGLONG
+ added hb_parnint, hb_stornint, hb_retnint, hb_retnintlen,
hb_itemPutNInt, hb_itemPutNIntLen, hb_itemGetNInt which operates on
HB_LONG
+ added HB_PUSHLONGLONG pcode
+ changed compiler and optimizer to use HB_LONG numbers and reduce
conversion from to double which may damage the 64bit number.
+ common functions for string to number conversions for compiler, RTL
and RDD to reduce problems with differ FL values for the same number:
hb_compStrToNum(), hb_valStrnToNum(), hb_strToNum(), hb_strnToNum()
+ common function hb_numRoun() which uses exactly the same algorithms
as string to number conversion for the same reason - please keep
this functions together.
+ hack inside hb_numRound() similar to the one used by CL5.3
+ hb_numInt() which uses uses the same hack as hb_numRound()
+ rewritten number to string conversion
+ some new string manipulation functions hb_strncpy(), hb_strncat(), ...
They works differ the the C one - always set 0 at the end, the buffer
has to be n+1 bytes length, the n is total size of buffer not the
left free space.
! cleaned some code which operates on ASCIIZ string to avoid potential
buffer overflow
+ updated RDD code - it's the first part - in few days I plan to change
workarea structure in both projects - it will break any 3rd party RDDs
so they have to be updated. I want to add SUPERTABLE into workarea
to allow creating new RDD on-line.
! cleaned the bugs with negating integers - on most machines (like x86)
the integers are not 0 symmetric - it means that x = -x does not work
for {INT,LONG,LONGLONG}_MIN (hb_vmNegate, ABS())
+ cleaned error messages to be Clipper compatible.
+ updated build process for .DEB packages - now hb* scripts and shared
libs are created by standard make install
* added new .prg #defines: __PLATFORM__<cPlatfrom>,
__ARCH{16|32|64}BIT__, __LITTLE_ENDIAN__|__BIG_ENDIAN__|__PDP_ENDIAN__
!!! cPlatfrom can have lower letters (for xHarbour compatibility)
If you do not like it please change it.
* others ...
1244 lines
42 KiB
C
1244 lines
42 KiB
C
/*
|
|
* $Id$
|
|
*/
|
|
|
|
/*
|
|
* Harbour Project source code:
|
|
* Compiler Expression Optimizer - reducing expressions
|
|
*
|
|
* Copyright 1999 Ryszard Glab
|
|
* www - http://www.harbour-project.org
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
* any later version.
|
|
*
|
|
* 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 software; see the file COPYING. If not, write to
|
|
* the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
|
|
* Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/).
|
|
*
|
|
* As a special exception, the Harbour Project gives permission for
|
|
* additional uses of the text contained in its release of Harbour.
|
|
*
|
|
* The exception is that, if you link the Harbour libraries with other
|
|
* files to produce an executable, this does not by itself cause the
|
|
* resulting executable to be covered by the GNU General Public License.
|
|
* Your use of that executable is in no way restricted on account of
|
|
* linking the Harbour library code into it.
|
|
*
|
|
* This exception does not however invalidate any other reasons why
|
|
* the executable file might be covered by the GNU General Public License.
|
|
*
|
|
* This exception applies only to the code released by the Harbour
|
|
* Project under the name Harbour. If you copy code from other
|
|
* Harbour Project or Free Software Foundation releases into a copy of
|
|
* Harbour, as the General Public License permits, the exception does
|
|
* not apply to the code that you add in this way. To avoid misleading
|
|
* anyone as to the status of such modified files, you must delete
|
|
* this exception notice from them.
|
|
*
|
|
* If you write modifications of your own for Harbour, it is your choice
|
|
* whether to permit this exception to apply to your modifications.
|
|
* If you do not wish that, delete this exception notice.
|
|
*
|
|
*/
|
|
|
|
/* TOFIX: Split the code, since MSC8 can't compile it, even in Huge model. */
|
|
|
|
/* TODO:
|
|
* - Correct post- and pre- operations to correctly handle the following code
|
|
* a[ i++ ]++
|
|
* Notice: in current implementation (an in Clipper too) 'i++' is evaluated
|
|
* two times! This causes that the new value (after incrementation) is
|
|
* stored in next element of the array.
|
|
*/
|
|
|
|
/* NOTE: This must be the first definition
|
|
* This is a common code shared by macro and standalone compiler
|
|
*/
|
|
#define HB_MACRO_SUPPORT
|
|
|
|
#include <math.h>
|
|
#include "hbmacro.h"
|
|
#include "hbcomp.h"
|
|
|
|
HB_EXPR_PTR hb_compExprReduceMod( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
HB_EXPR_PTR pLeft, pRight;
|
|
|
|
pLeft = pSelf->value.asOperator.pLeft;
|
|
pRight = pSelf->value.asOperator.pRight;
|
|
|
|
if( pLeft->ExprType == HB_ET_NUMERIC && pRight->ExprType == HB_ET_NUMERIC )
|
|
{
|
|
if( pLeft->value.asNum.NumType == HB_ET_LONG && pRight->value.asNum.NumType == HB_ET_LONG )
|
|
{
|
|
if( pRight->value.asNum.lVal )
|
|
{
|
|
HB_LONG lVal = pLeft->value.asNum.lVal % pRight->value.asNum.lVal;
|
|
|
|
pSelf->value.asNum.lVal = lVal;
|
|
pSelf->value.asNum.bDec = 0;
|
|
pSelf->value.asNum.NumType = HB_ET_LONG;
|
|
pSelf->ExprType = HB_ET_NUMERIC;
|
|
pSelf->ValType = HB_EV_NUMERIC;
|
|
hb_compExprFree( pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pRight, HB_MACRO_PARAM );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* TODO: Check for incompatible types e.g. 3 % "txt"
|
|
*/
|
|
}
|
|
return pSelf;
|
|
}
|
|
|
|
HB_EXPR_PTR hb_compExprReduceDiv( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
HB_EXPR_PTR pLeft, pRight;
|
|
|
|
pLeft = pSelf->value.asOperator.pLeft;
|
|
pRight = pSelf->value.asOperator.pRight;
|
|
|
|
if( pLeft->ExprType == HB_ET_NUMERIC && pRight->ExprType == HB_ET_NUMERIC )
|
|
{
|
|
BYTE bType = ( pLeft->value.asNum.NumType & pRight->value.asNum.NumType );
|
|
|
|
switch( bType )
|
|
{
|
|
case HB_ET_LONG:
|
|
|
|
if( pRight->value.asNum.lVal )
|
|
{
|
|
if( pLeft->value.asNum.lVal % pRight->value.asNum.lVal == 0 )
|
|
{
|
|
/* Return integer results as long */
|
|
pSelf->value.asNum.lVal = pLeft->value.asNum.lVal / pRight->value.asNum.lVal;
|
|
pSelf->value.asNum.bDec = 0;
|
|
pSelf->value.asNum.NumType = HB_ET_LONG;
|
|
}
|
|
else
|
|
{
|
|
/* Return non-integer results as double */
|
|
pSelf->value.asNum.dVal = ( double ) pLeft->value.asNum.lVal / ( double ) pRight->value.asNum.lVal;
|
|
pSelf->value.asNum.bWidth = HB_DEFAULT_WIDTH;
|
|
pSelf->value.asNum.bDec = HB_DEFAULT_DECIMALS;
|
|
pSelf->value.asNum.NumType = HB_ET_DOUBLE;
|
|
}
|
|
pSelf->ExprType = HB_ET_NUMERIC;
|
|
}
|
|
break;
|
|
|
|
case HB_ET_DOUBLE:
|
|
|
|
if( pRight->value.asNum.dVal != 0.0 )
|
|
{
|
|
pSelf->value.asNum.dVal = pLeft->value.asNum.dVal / pRight->value.asNum.dVal;
|
|
pSelf->value.asNum.bWidth = HB_DEFAULT_WIDTH;
|
|
pSelf->value.asNum.bDec = HB_DEFAULT_DECIMALS;
|
|
pSelf->value.asNum.NumType = HB_ET_DOUBLE;
|
|
pSelf->ExprType = HB_ET_NUMERIC;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
|
|
if( pLeft->value.asNum.NumType == HB_ET_DOUBLE )
|
|
{
|
|
if( pRight->value.asNum.lVal )
|
|
{
|
|
pSelf->value.asNum.dVal = pLeft->value.asNum.dVal / ( double ) pRight->value.asNum.lVal;
|
|
pSelf->value.asNum.bWidth = HB_DEFAULT_WIDTH;
|
|
pSelf->value.asNum.bDec = HB_DEFAULT_DECIMALS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( pRight->value.asNum.dVal != 0.0 )
|
|
{
|
|
pSelf->value.asNum.dVal = ( double ) pLeft->value.asNum.lVal / pRight->value.asNum.dVal;
|
|
pSelf->value.asNum.bWidth = HB_DEFAULT_WIDTH;
|
|
pSelf->value.asNum.bDec = HB_DEFAULT_DECIMALS;
|
|
}
|
|
}
|
|
|
|
pSelf->value.asNum.NumType = HB_ET_DOUBLE;
|
|
pSelf->ExprType = HB_ET_NUMERIC;
|
|
|
|
} /* switch bType */
|
|
|
|
if( pSelf->ExprType == HB_ET_NUMERIC )
|
|
{
|
|
/* The expression was reduced - delete old components */
|
|
pSelf->ValType = HB_EV_NUMERIC;
|
|
hb_compExprFree( pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pRight, HB_MACRO_PARAM );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* TODO: Check for incompatible types e.g. 3 / "txt"
|
|
*/
|
|
}
|
|
return pSelf;
|
|
}
|
|
|
|
HB_EXPR_PTR hb_compExprReduceMult( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
HB_EXPR_PTR pLeft, pRight;
|
|
|
|
pLeft = pSelf->value.asOperator.pLeft;
|
|
pRight = pSelf->value.asOperator.pRight;
|
|
|
|
if( pLeft->ExprType == HB_ET_NUMERIC && pRight->ExprType == HB_ET_NUMERIC )
|
|
{
|
|
BYTE bType = ( pLeft->value.asNum.NumType & pRight->value.asNum.NumType );
|
|
|
|
switch( bType )
|
|
{
|
|
case HB_ET_LONG:
|
|
{
|
|
HB_MAXDBL dVal = ( HB_MAXDBL ) pLeft->value.asNum.lVal * ( HB_MAXDBL ) pRight->value.asNum.lVal;
|
|
|
|
if ( HB_DBL_LIM_LONG( dVal ) )
|
|
{
|
|
pSelf->value.asNum.lVal = ( HB_LONG ) dVal;
|
|
pSelf->value.asNum.bDec = 0;
|
|
pSelf->value.asNum.NumType = HB_ET_LONG;
|
|
}
|
|
else
|
|
{
|
|
pSelf->value.asNum.dVal = ( double ) dVal;
|
|
pSelf->value.asNum.bWidth = HB_DEFAULT_WIDTH;
|
|
pSelf->value.asNum.bDec = 0;
|
|
pSelf->value.asNum.NumType = HB_ET_DOUBLE;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case HB_ET_DOUBLE:
|
|
{
|
|
pSelf->value.asNum.dVal = pLeft->value.asNum.dVal * pRight->value.asNum.dVal;
|
|
pSelf->value.asNum.bWidth = HB_DEFAULT_WIDTH;
|
|
pSelf->value.asNum.bDec = pLeft->value.asNum.bDec + pRight->value.asNum.bDec;
|
|
pSelf->value.asNum.NumType = HB_ET_DOUBLE;
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
if( pLeft->value.asNum.NumType == HB_ET_DOUBLE )
|
|
{
|
|
pSelf->value.asNum.dVal = pLeft->value.asNum.dVal * ( double ) pRight->value.asNum.lVal;
|
|
pSelf->value.asNum.bWidth = HB_DEFAULT_WIDTH;
|
|
pSelf->value.asNum.bDec = pLeft->value.asNum.bDec;
|
|
}
|
|
else
|
|
{
|
|
pSelf->value.asNum.dVal = ( double ) pLeft->value.asNum.lVal * pRight->value.asNum.dVal;
|
|
pSelf->value.asNum.bWidth = HB_DEFAULT_WIDTH;
|
|
pSelf->value.asNum.bDec = pRight->value.asNum.bDec;
|
|
}
|
|
pSelf->value.asNum.NumType = HB_ET_DOUBLE;
|
|
}
|
|
}
|
|
pSelf->ExprType = HB_ET_NUMERIC;
|
|
pSelf->ValType = HB_EV_NUMERIC;
|
|
hb_compExprFree( pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pRight, HB_MACRO_PARAM );
|
|
}
|
|
else
|
|
{
|
|
/* TODO: Check for incompatible types e.g. 3 * "txt"
|
|
*/
|
|
}
|
|
return pSelf;
|
|
}
|
|
|
|
HB_EXPR_PTR hb_compExprReduceMinus( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
HB_EXPR_PTR pLeft, pRight;
|
|
|
|
pLeft = pSelf->value.asOperator.pLeft;
|
|
pRight = pSelf->value.asOperator.pRight;
|
|
|
|
if( pLeft->ExprType == HB_ET_NUMERIC && pRight->ExprType == HB_ET_NUMERIC )
|
|
{
|
|
BYTE bType = ( pLeft->value.asNum.NumType & pRight->value.asNum.NumType );
|
|
|
|
switch( bType )
|
|
{
|
|
case HB_ET_LONG:
|
|
{
|
|
HB_MAXDBL dVal = ( HB_MAXDBL ) pLeft->value.asNum.lVal - ( HB_MAXDBL ) pRight->value.asNum.lVal;
|
|
|
|
if ( HB_DBL_LIM_LONG( dVal ) )
|
|
{
|
|
pSelf->value.asNum.lVal = ( HB_LONG ) dVal;
|
|
pSelf->value.asNum.bDec = 0;
|
|
pSelf->value.asNum.NumType = HB_ET_LONG;
|
|
}
|
|
else
|
|
{
|
|
pSelf->value.asNum.dVal = ( double ) dVal;
|
|
pSelf->value.asNum.bWidth = HB_DEFAULT_WIDTH;
|
|
pSelf->value.asNum.bDec = 0;
|
|
pSelf->value.asNum.NumType = HB_ET_DOUBLE;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case HB_ET_DOUBLE:
|
|
{
|
|
pSelf->value.asNum.dVal = pLeft->value.asNum.dVal - pRight->value.asNum.dVal;
|
|
pSelf->value.asNum.bWidth = HB_DEFAULT_WIDTH;
|
|
if( pLeft->value.asNum.bDec < pRight->value.asNum.bDec )
|
|
pSelf->value.asNum.bDec = pRight->value.asNum.bDec;
|
|
else
|
|
pSelf->value.asNum.bDec = pLeft->value.asNum.bDec;
|
|
pSelf->value.asNum.NumType = HB_ET_DOUBLE;
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
if( pLeft->value.asNum.NumType == HB_ET_DOUBLE )
|
|
{
|
|
pSelf->value.asNum.dVal = pLeft->value.asNum.dVal - ( double ) pRight->value.asNum.lVal;
|
|
pSelf->value.asNum.bWidth = HB_DEFAULT_WIDTH;
|
|
pSelf->value.asNum.bDec = pLeft->value.asNum.bDec;
|
|
}
|
|
else
|
|
{
|
|
pSelf->value.asNum.dVal = ( double ) pLeft->value.asNum.lVal - pRight->value.asNum.dVal;
|
|
pSelf->value.asNum.bWidth = HB_DEFAULT_WIDTH;
|
|
pSelf->value.asNum.bDec = pRight->value.asNum.bDec;
|
|
}
|
|
pSelf->value.asNum.NumType = HB_ET_DOUBLE;
|
|
}
|
|
}
|
|
pSelf->ExprType = HB_ET_NUMERIC;
|
|
pSelf->ValType = HB_EV_NUMERIC;
|
|
hb_compExprFree( pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pRight, HB_MACRO_PARAM );
|
|
}
|
|
else if( pLeft->ExprType == HB_ET_STRING && pRight->ExprType == HB_ET_STRING )
|
|
{
|
|
/* TODO:
|
|
*/
|
|
}
|
|
else
|
|
{
|
|
/* TODO: Check for incompatible types e.g. "txt" - 3
|
|
*/
|
|
}
|
|
return pSelf;
|
|
}
|
|
|
|
HB_EXPR_PTR hb_compExprReducePlus( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
HB_EXPR_PTR pLeft, pRight;
|
|
|
|
pLeft = pSelf->value.asOperator.pLeft;
|
|
pRight = pSelf->value.asOperator.pRight;
|
|
|
|
if( pLeft->ExprType == HB_ET_NUMERIC && pRight->ExprType == HB_ET_NUMERIC )
|
|
{
|
|
BYTE bType = ( pLeft->value.asNum.NumType & pRight->value.asNum.NumType );
|
|
|
|
switch( bType )
|
|
{
|
|
case HB_ET_LONG:
|
|
{
|
|
HB_MAXDBL dVal = ( HB_MAXDBL ) pLeft->value.asNum.lVal + ( HB_MAXDBL ) pRight->value.asNum.lVal;
|
|
|
|
if ( HB_DBL_LIM_LONG( dVal ) )
|
|
{
|
|
pSelf->value.asNum.lVal = ( HB_LONG ) dVal;
|
|
pSelf->value.asNum.bDec = 0;
|
|
pSelf->value.asNum.NumType = HB_ET_LONG;
|
|
}
|
|
else
|
|
{
|
|
pSelf->value.asNum.dVal = ( double ) dVal;
|
|
pSelf->value.asNum.bWidth = HB_DEFAULT_WIDTH;
|
|
pSelf->value.asNum.bDec = 0;
|
|
pSelf->value.asNum.NumType = HB_ET_DOUBLE;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case HB_ET_DOUBLE:
|
|
{
|
|
pSelf->value.asNum.dVal = pLeft->value.asNum.dVal + pRight->value.asNum.dVal;
|
|
pSelf->value.asNum.bWidth = HB_DEFAULT_WIDTH;
|
|
if( pLeft->value.asNum.bDec < pRight->value.asNum.bDec )
|
|
pSelf->value.asNum.bDec = pRight->value.asNum.bDec;
|
|
else
|
|
pSelf->value.asNum.bDec = pLeft->value.asNum.bDec;
|
|
pSelf->value.asNum.NumType = HB_ET_DOUBLE;
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
if( pLeft->value.asNum.NumType == HB_ET_DOUBLE )
|
|
{
|
|
pSelf->value.asNum.dVal = pLeft->value.asNum.dVal + ( double ) pRight->value.asNum.lVal;
|
|
pSelf->value.asNum.bWidth = HB_DEFAULT_WIDTH;
|
|
pSelf->value.asNum.bDec = pLeft->value.asNum.bDec;
|
|
}
|
|
else
|
|
{
|
|
pSelf->value.asNum.dVal = ( double ) pLeft->value.asNum.lVal + pRight->value.asNum.dVal;
|
|
pSelf->value.asNum.bWidth = HB_DEFAULT_WIDTH;
|
|
pSelf->value.asNum.bDec = pRight->value.asNum.bDec;
|
|
}
|
|
pSelf->value.asNum.NumType = HB_ET_DOUBLE;
|
|
}
|
|
}
|
|
pSelf->ExprType = HB_ET_NUMERIC;
|
|
pSelf->ValType = HB_EV_NUMERIC;
|
|
hb_compExprFree( pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pRight, HB_MACRO_PARAM );
|
|
}
|
|
else if( pLeft->ExprType == HB_ET_STRING && pRight->ExprType == HB_ET_STRING )
|
|
{
|
|
if( pRight->ulLength == 0 )
|
|
{
|
|
pSelf->ExprType = HB_ET_NONE; /* suppress deletion of operator components */
|
|
hb_compExprFree( pSelf, HB_MACRO_PARAM );
|
|
pSelf = pLeft;
|
|
hb_compExprFree( pRight, HB_MACRO_PARAM );
|
|
}
|
|
else if( pLeft->ulLength == 0 )
|
|
{
|
|
pSelf->ExprType = HB_ET_NONE; /* suppress deletion of operator components */
|
|
hb_compExprFree( pSelf, HB_MACRO_PARAM );
|
|
pSelf = pRight;
|
|
hb_compExprFree( pLeft, HB_MACRO_PARAM );
|
|
}
|
|
else
|
|
{
|
|
/* Do not reduce strings with the macro operator '&'
|
|
*/
|
|
if( strchr(pLeft->value.asString.string, '&') == NULL )
|
|
{
|
|
pSelf->ExprType = HB_ET_NONE; /* suppress deletion of operator components */
|
|
hb_compExprFree( pSelf, HB_MACRO_PARAM );
|
|
pSelf = hb_compExprReducePlusStrings( pLeft, pRight, HB_MACRO_PARAM );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* TODO: Check for incompatible types e.g. "txt" + 3
|
|
*/
|
|
}
|
|
return pSelf;
|
|
}
|
|
|
|
|
|
HB_EXPR_PTR hb_compExprReduceIN( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
if( ( pSelf->value.asOperator.pLeft->ExprType == pSelf->value.asOperator.pRight->ExprType ) && pSelf->value.asOperator.pLeft->ExprType == HB_ET_STRING )
|
|
{
|
|
/* Both arguments are literal strings
|
|
*/
|
|
BOOL bResult;
|
|
|
|
/* NOTE: CA-Cl*pper has a bug where the $ operator returns .T.
|
|
when an empty string is searched [vszakats] */
|
|
|
|
if( pSelf->value.asOperator.pLeft->ulLength == 0 )
|
|
bResult = TRUE;
|
|
else
|
|
bResult = ( hb_strAt( pSelf->value.asOperator.pLeft->value.asString.string, pSelf->value.asOperator.pLeft->ulLength,
|
|
pSelf->value.asOperator.pRight->value.asString.string, pSelf->value.asOperator.pRight->ulLength ) != 0 );
|
|
|
|
/* NOTE:
|
|
* "" $ "XXX" = .T.
|
|
* "" $ "" = .T.
|
|
*/
|
|
hb_compExprFree( pSelf->value.asOperator.pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asOperator.pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = bResult;
|
|
}
|
|
/* TODO: add checking for incompatible types
|
|
*/
|
|
return pSelf;
|
|
}
|
|
|
|
HB_EXPR_PTR hb_compExprReduceNE( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
HB_EXPR_PTR pLeft, pRight;
|
|
|
|
pLeft = pSelf->value.asOperator.pLeft;
|
|
pRight = pSelf->value.asOperator.pRight;
|
|
|
|
if( pLeft->ExprType == pRight->ExprType )
|
|
switch( pLeft->ExprType )
|
|
{
|
|
case HB_ET_LOGICAL:
|
|
{
|
|
/* .F. != .T. = .T.
|
|
* .T. != .T. = .F.
|
|
* .F. != .F. = .F.
|
|
* .T. != .F. = .T.
|
|
*/
|
|
BOOL bResult = ( pLeft->value.asLogical != pRight->value.asLogical );
|
|
hb_compExprFree( pSelf->value.asOperator.pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asOperator.pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = bResult;
|
|
}
|
|
break;
|
|
|
|
case HB_ET_STRING:
|
|
/* NOTE: the result depends on SET EXACT setting then it
|
|
* cannot be optimized except the case when NULL string are
|
|
* compared - "" != "" is always FALSE regardless of EXACT
|
|
* setting
|
|
*/
|
|
if( (pLeft->ulLength | pRight->ulLength) == 0 )
|
|
{
|
|
hb_compExprFree( pSelf->value.asOperator.pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asOperator.pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = FALSE;
|
|
|
|
/* NOTE: COMPATIBILITY: Clipper doesn't optimize this */
|
|
}
|
|
break;
|
|
|
|
case HB_ET_NUMERIC:
|
|
{
|
|
BOOL bResult;
|
|
|
|
switch( pLeft->value.asNum.NumType & pRight->value.asNum.NumType )
|
|
{
|
|
case HB_ET_LONG:
|
|
bResult = ( pLeft->value.asNum.lVal != pRight->value.asNum.lVal );
|
|
break;
|
|
case HB_ET_DOUBLE:
|
|
bResult = ( pLeft->value.asNum.dVal != pRight->value.asNum.dVal );
|
|
break;
|
|
default:
|
|
{
|
|
if( pLeft->value.asNum.NumType == HB_ET_LONG )
|
|
bResult = ( pLeft->value.asNum.lVal != pRight->value.asNum.dVal );
|
|
else
|
|
bResult = ( pLeft->value.asNum.dVal != pRight->value.asNum.lVal );
|
|
}
|
|
break;
|
|
}
|
|
hb_compExprFree( pSelf->value.asOperator.pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asOperator.pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = bResult;
|
|
}
|
|
break;
|
|
|
|
}
|
|
/* TODO: add checking of incompatible types
|
|
else
|
|
{
|
|
}
|
|
*/
|
|
return pSelf;
|
|
}
|
|
|
|
HB_EXPR_PTR hb_compExprReduceGE( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
HB_EXPR_PTR pLeft, pRight;
|
|
|
|
pLeft = pSelf->value.asOperator.pLeft;
|
|
pRight = pSelf->value.asOperator.pRight;
|
|
|
|
if( pLeft->ExprType == pRight->ExprType )
|
|
switch( pLeft->ExprType )
|
|
{
|
|
case HB_ET_LOGICAL:
|
|
{
|
|
/* .T. >= .F. = .T.
|
|
* .T. >= .T. = .T.
|
|
* .F. >= .F. = .T.
|
|
* .F. >= .T. = .f.
|
|
*/
|
|
BOOL bResult = ! ( ! pLeft->value.asLogical && pRight->value.asLogical );
|
|
hb_compExprFree( pSelf->value.asOperator.pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asOperator.pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = bResult;
|
|
}
|
|
break;
|
|
|
|
case HB_ET_NUMERIC:
|
|
{
|
|
BOOL bResult;
|
|
|
|
switch( pLeft->value.asNum.NumType & pRight->value.asNum.NumType )
|
|
{
|
|
case HB_ET_LONG:
|
|
bResult = ( pLeft->value.asNum.lVal >= pRight->value.asNum.lVal );
|
|
break;
|
|
case HB_ET_DOUBLE:
|
|
bResult = ( pLeft->value.asNum.dVal >= pRight->value.asNum.dVal );
|
|
break;
|
|
default:
|
|
{
|
|
if( pLeft->value.asNum.NumType == HB_ET_LONG )
|
|
bResult = ( pLeft->value.asNum.lVal >= pRight->value.asNum.dVal );
|
|
else
|
|
bResult = ( pLeft->value.asNum.dVal >= pRight->value.asNum.lVal );
|
|
}
|
|
break;
|
|
}
|
|
hb_compExprFree( pSelf->value.asOperator.pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asOperator.pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = bResult;
|
|
}
|
|
break;
|
|
|
|
}
|
|
/* TODO: add checking of incompatible types
|
|
else
|
|
{
|
|
}
|
|
*/
|
|
return pSelf;
|
|
}
|
|
|
|
HB_EXPR_PTR hb_compExprReduceLE( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
HB_EXPR_PTR pLeft, pRight;
|
|
|
|
pLeft = pSelf->value.asOperator.pLeft;
|
|
pRight = pSelf->value.asOperator.pRight;
|
|
|
|
if( pLeft->ExprType == pRight->ExprType )
|
|
switch( pLeft->ExprType )
|
|
{
|
|
case HB_ET_LOGICAL:
|
|
{
|
|
/* .T. <= .F. = .F.
|
|
* .T. <= .T. = .T.
|
|
* .F. <= .F. = .T.
|
|
* .F. <= .T. = .T.
|
|
*/
|
|
BOOL bResult = ! ( pLeft->value.asLogical && ! pRight->value.asLogical );
|
|
hb_compExprFree( pSelf->value.asOperator.pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asOperator.pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = bResult;
|
|
}
|
|
break;
|
|
|
|
case HB_ET_NUMERIC:
|
|
{
|
|
BOOL bResult;
|
|
|
|
switch( pLeft->value.asNum.NumType & pRight->value.asNum.NumType )
|
|
{
|
|
case HB_ET_LONG:
|
|
bResult = ( pLeft->value.asNum.lVal <= pRight->value.asNum.lVal );
|
|
break;
|
|
case HB_ET_DOUBLE:
|
|
bResult = ( pLeft->value.asNum.dVal <= pRight->value.asNum.dVal );
|
|
break;
|
|
default:
|
|
{
|
|
if( pLeft->value.asNum.NumType == HB_ET_LONG )
|
|
bResult = ( pLeft->value.asNum.lVal <= pRight->value.asNum.dVal );
|
|
else
|
|
bResult = ( pLeft->value.asNum.dVal <= pRight->value.asNum.lVal );
|
|
}
|
|
break;
|
|
}
|
|
hb_compExprFree( pSelf->value.asOperator.pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asOperator.pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = bResult;
|
|
}
|
|
break;
|
|
|
|
}
|
|
/* TODO: add checking of incompatible types
|
|
else
|
|
{
|
|
}
|
|
*/
|
|
return pSelf;
|
|
}
|
|
|
|
HB_EXPR_PTR hb_compExprReduceGT( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
HB_EXPR_PTR pLeft, pRight;
|
|
|
|
pLeft = pSelf->value.asOperator.pLeft;
|
|
pRight = pSelf->value.asOperator.pRight;
|
|
|
|
if( pLeft->ExprType == pRight->ExprType )
|
|
switch( pLeft->ExprType )
|
|
{
|
|
case HB_ET_LOGICAL:
|
|
{
|
|
/* .T. > .F. = .T.
|
|
* .T. > .T. = .F.
|
|
* .F. > .F. = .F.
|
|
* .F. > .T. = .F.
|
|
*/
|
|
BOOL bResult = ( pLeft->value.asLogical && ! pRight->value.asLogical );
|
|
hb_compExprFree( pSelf->value.asOperator.pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asOperator.pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = bResult;
|
|
}
|
|
break;
|
|
|
|
case HB_ET_NUMERIC:
|
|
{
|
|
BOOL bResult;
|
|
|
|
switch( pLeft->value.asNum.NumType & pRight->value.asNum.NumType )
|
|
{
|
|
case HB_ET_LONG:
|
|
bResult = ( pLeft->value.asNum.lVal > pRight->value.asNum.lVal );
|
|
break;
|
|
case HB_ET_DOUBLE:
|
|
bResult = ( pLeft->value.asNum.dVal > pRight->value.asNum.dVal );
|
|
break;
|
|
default:
|
|
{
|
|
if( pLeft->value.asNum.NumType == HB_ET_LONG )
|
|
bResult = ( pLeft->value.asNum.lVal > pRight->value.asNum.dVal );
|
|
else
|
|
bResult = ( pLeft->value.asNum.dVal > pRight->value.asNum.lVal );
|
|
}
|
|
break;
|
|
}
|
|
hb_compExprFree( pSelf->value.asOperator.pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asOperator.pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = bResult;
|
|
}
|
|
break;
|
|
|
|
}
|
|
/* TODO: add checking of incompatible types
|
|
else
|
|
{
|
|
}
|
|
*/
|
|
return pSelf;
|
|
}
|
|
|
|
HB_EXPR_PTR hb_compExprReduceLT( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
HB_EXPR_PTR pLeft, pRight;
|
|
|
|
pLeft = pSelf->value.asOperator.pLeft;
|
|
pRight = pSelf->value.asOperator.pRight;
|
|
|
|
if( pLeft->ExprType == pRight->ExprType )
|
|
switch( pLeft->ExprType )
|
|
{
|
|
case HB_ET_LOGICAL:
|
|
{
|
|
/* .F. < .T. = .T.
|
|
* .T. < .T. = .F.
|
|
* .F. < .F. = .F.
|
|
* .T. < .F. = .F.
|
|
*/
|
|
BOOL bResult = ( ! pLeft->value.asLogical && pRight->value.asLogical );
|
|
hb_compExprFree( pSelf->value.asOperator.pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asOperator.pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = bResult;
|
|
}
|
|
break;
|
|
|
|
case HB_ET_NUMERIC:
|
|
{
|
|
BOOL bResult;
|
|
|
|
switch( pLeft->value.asNum.NumType & pRight->value.asNum.NumType )
|
|
{
|
|
case HB_ET_LONG:
|
|
bResult = ( pLeft->value.asNum.lVal < pRight->value.asNum.lVal );
|
|
break;
|
|
case HB_ET_DOUBLE:
|
|
bResult = ( pLeft->value.asNum.dVal < pRight->value.asNum.dVal );
|
|
break;
|
|
default:
|
|
{
|
|
if( pLeft->value.asNum.NumType == HB_ET_LONG )
|
|
bResult = ( pLeft->value.asNum.lVal < pRight->value.asNum.dVal );
|
|
else
|
|
bResult = ( pLeft->value.asNum.dVal < pRight->value.asNum.lVal );
|
|
}
|
|
break;
|
|
}
|
|
hb_compExprFree( pSelf->value.asOperator.pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asOperator.pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = bResult;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
/* TODO: add checking of incompatible types
|
|
else
|
|
{
|
|
}
|
|
*/
|
|
return pSelf;
|
|
}
|
|
|
|
HB_EXPR_PTR hb_compExprReduceEQ( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
HB_EXPR_PTR pLeft, pRight;
|
|
|
|
pLeft = pSelf->value.asOperator.pLeft;
|
|
pRight = pSelf->value.asOperator.pRight;
|
|
|
|
if( pLeft->ExprType == pRight->ExprType )
|
|
{
|
|
switch( pLeft->ExprType )
|
|
{
|
|
case HB_ET_LOGICAL:
|
|
{
|
|
BOOL bResult = ( pLeft->value.asLogical == pRight->value.asLogical );
|
|
hb_compExprFree( pSelf->value.asOperator.pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asOperator.pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = bResult;
|
|
}
|
|
break;
|
|
|
|
case HB_ET_STRING:
|
|
{
|
|
BOOL bResult = FALSE;
|
|
|
|
if( pLeft->ulLength == pRight->ulLength )
|
|
bResult = ( strcmp( pLeft->value.asString.string, pRight->value.asString.string ) == 0 );
|
|
hb_compExprFree( pSelf->value.asOperator.pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asOperator.pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = bResult;
|
|
}
|
|
break;
|
|
|
|
case HB_ET_NUMERIC:
|
|
{
|
|
BOOL bResult;
|
|
|
|
switch( pLeft->value.asNum.NumType & pRight->value.asNum.NumType )
|
|
{
|
|
case HB_ET_LONG:
|
|
bResult = ( pLeft->value.asNum.lVal == pRight->value.asNum.lVal );
|
|
break;
|
|
case HB_ET_DOUBLE:
|
|
bResult = ( pLeft->value.asNum.dVal == pRight->value.asNum.dVal );
|
|
break;
|
|
default:
|
|
{
|
|
if( pLeft->value.asNum.NumType == HB_ET_LONG )
|
|
bResult = ( pLeft->value.asNum.lVal == pRight->value.asNum.dVal );
|
|
else
|
|
bResult = ( pLeft->value.asNum.dVal == pRight->value.asNum.lVal );
|
|
}
|
|
break;
|
|
}
|
|
hb_compExprFree( pSelf->value.asOperator.pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asOperator.pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = bResult;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
/* TODO: add checking of incompatible types
|
|
else
|
|
{
|
|
}
|
|
*/
|
|
return pSelf;
|
|
}
|
|
|
|
HB_EXPR_PTR hb_compExprReduceAnd( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
HB_EXPR_PTR pLeft, pRight;
|
|
|
|
pLeft = pSelf->value.asOperator.pLeft;
|
|
pRight = pSelf->value.asOperator.pRight;
|
|
|
|
if( pLeft->ExprType == HB_ET_LOGICAL && pRight->ExprType == HB_ET_LOGICAL )
|
|
{
|
|
BOOL bResult;
|
|
|
|
bResult = pLeft->value.asLogical && pRight->value.asLogical;
|
|
hb_compExprFree( pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = bResult;
|
|
}
|
|
else if( pLeft->ExprType == HB_ET_LOGICAL && hb_comp_bShortCuts )
|
|
{
|
|
if( pLeft->value.asLogical )
|
|
{
|
|
/* .T. .AND. expr => expr
|
|
*/
|
|
hb_compExprFree( pLeft, HB_MACRO_PARAM);
|
|
pSelf->ExprType = HB_ET_NONE; /* don't delete expression components */
|
|
hb_compExprFree( pSelf, HB_MACRO_PARAM );
|
|
pSelf = pRight;
|
|
}
|
|
else
|
|
{
|
|
/* .F. .AND. expr => .F.
|
|
*/
|
|
hb_compExprFree( pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pRight, HB_MACRO_PARAM ); /* discard expression */
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = FALSE;
|
|
}
|
|
}
|
|
else if( pRight->ExprType == HB_ET_LOGICAL && hb_comp_bShortCuts )
|
|
{
|
|
if( pRight->value.asLogical )
|
|
{
|
|
/* expr .AND. .T. => expr
|
|
*/
|
|
hb_compExprFree( pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_NONE; /* don't delete expression components */
|
|
hb_compExprFree( pSelf, HB_MACRO_PARAM );
|
|
pSelf = pLeft;
|
|
}
|
|
else
|
|
{
|
|
/* expr .AND. .F. => .F.
|
|
*/
|
|
hb_compExprFree( pLeft, HB_MACRO_PARAM ); /* discard expression */
|
|
hb_compExprFree( pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = FALSE;
|
|
}
|
|
}
|
|
return pSelf;
|
|
}
|
|
|
|
HB_EXPR_PTR hb_compExprReduceOr( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
HB_EXPR_PTR pLeft, pRight;
|
|
|
|
pLeft = pSelf->value.asOperator.pLeft;
|
|
pRight = pSelf->value.asOperator.pRight;
|
|
|
|
if( pLeft->ExprType == HB_ET_LOGICAL && pRight->ExprType == HB_ET_LOGICAL )
|
|
{
|
|
BOOL bResult;
|
|
|
|
bResult = pLeft->value.asLogical || pRight->value.asLogical;
|
|
hb_compExprFree( pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = bResult;
|
|
}
|
|
else if( pLeft->ExprType == HB_ET_LOGICAL && hb_comp_bShortCuts )
|
|
{
|
|
if( pLeft->value.asLogical )
|
|
{
|
|
/* .T. .OR. expr => .T.
|
|
*/
|
|
hb_compExprFree( pLeft, HB_MACRO_PARAM );
|
|
hb_compExprFree( pRight, HB_MACRO_PARAM ); /* discard expression */
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = TRUE;
|
|
}
|
|
else
|
|
{
|
|
/* .F. .OR. expr => expr
|
|
*/
|
|
hb_compExprFree( pLeft, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_NONE; /* don't delete expression components */
|
|
hb_compExprFree( pSelf, HB_MACRO_PARAM );
|
|
pSelf = pRight;
|
|
}
|
|
}
|
|
else if( pRight->ExprType == HB_ET_LOGICAL && hb_comp_bShortCuts )
|
|
{
|
|
if( pRight->value.asLogical )
|
|
{
|
|
/* expr .OR. .T. => .T.
|
|
*/
|
|
hb_compExprFree( pLeft, HB_MACRO_PARAM ); /* discard expression */
|
|
hb_compExprFree( pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_LOGICAL;
|
|
pSelf->ValType = HB_EV_LOGICAL;
|
|
pSelf->value.asLogical = TRUE;
|
|
}
|
|
else
|
|
{
|
|
/* expr .OR. .F. => expr
|
|
*/
|
|
hb_compExprFree( pRight, HB_MACRO_PARAM );
|
|
pSelf->ExprType = HB_ET_NONE; /* don't delete expression components */
|
|
hb_compExprFree( pSelf, HB_MACRO_PARAM );
|
|
pSelf = pLeft;
|
|
}
|
|
}
|
|
return pSelf;
|
|
}
|
|
|
|
HB_EXPR_PTR hb_compExprReduceIIF( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
HB_EXPR_PTR pExpr;
|
|
|
|
pExpr =pSelf->value.asList.pExprList; /* get conditional expression */
|
|
if( pExpr->ExprType == HB_ET_LOGICAL )
|
|
{
|
|
/* the condition was reduced to a logical value: .T. or .F.
|
|
*/
|
|
if( pExpr->value.asLogical )
|
|
{
|
|
/* .T. was specified
|
|
*/
|
|
pExpr = pExpr->pNext; /* skip to TRUE expression */
|
|
/* delete condition - it is no longer needed
|
|
*/
|
|
hb_compExprFree( pSelf->value.asList.pExprList, HB_MACRO_PARAM );
|
|
/* assign NULL to a start of expressions list to suppress
|
|
* deletion of expression's components - we are deleting them
|
|
* here
|
|
*/
|
|
pSelf->value.asList.pExprList = NULL;
|
|
hb_compExprFree( pSelf, HB_MACRO_PARAM );
|
|
/* store the TRUE expression as a result of reduction
|
|
*/
|
|
pSelf = pExpr;
|
|
pExpr = pExpr->pNext; /* skip to FALSE expression */
|
|
hb_compExprFree( pExpr, HB_MACRO_PARAM ); /* delete FALSE expr */
|
|
pSelf->pNext = NULL;
|
|
}
|
|
else
|
|
{
|
|
/* .F. was specified
|
|
*/
|
|
pExpr = pExpr->pNext; /* skip to TRUE expression */
|
|
/* delete condition - it is no longer needed
|
|
*/
|
|
hb_compExprFree( pSelf->value.asList.pExprList, HB_MACRO_PARAM );
|
|
/* assign NULL to a start of expressions list to suppress
|
|
* deletion of expression's components - we are deleting them
|
|
* here
|
|
*/
|
|
pSelf->value.asList.pExprList = NULL;
|
|
hb_compExprFree( pSelf, HB_MACRO_PARAM );
|
|
/* store the FALSE expression as a result of reduction
|
|
*/
|
|
pSelf = pExpr->pNext;
|
|
hb_compExprFree( pExpr, HB_MACRO_PARAM ); /* delete TRUE expr */
|
|
pSelf->pNext = NULL;
|
|
}
|
|
}
|
|
/* check if valid expression is passed
|
|
*/
|
|
else if( ( pExpr->ExprType == HB_ET_DOUBLE ) ||
|
|
( pExpr->ExprType == HB_ET_LONG ) ||
|
|
( pExpr->ExprType == HB_ET_NIL ) ||
|
|
( pExpr->ExprType == HB_ET_STRING ) ||
|
|
( pExpr->ExprType == HB_ET_CODEBLOCK ) ||
|
|
( pExpr->ExprType == HB_ET_SELF ) ||
|
|
( pExpr->ExprType == HB_ET_ARRAY ) )
|
|
{
|
|
hb_compExprErrorType( pExpr, HB_MACRO_PARAM );
|
|
}
|
|
return pSelf;
|
|
}
|
|
|
|
/* replace the list containing a single expression with a simple expression
|
|
* - strips parenthesis
|
|
* ( EXPR ) -> EXPR
|
|
*/
|
|
HB_EXPR_PTR hb_compExprListStrip( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
if( pSelf->ExprType == HB_ET_LIST )
|
|
{
|
|
ULONG ulCount = hb_compExprListLen( pSelf );
|
|
|
|
if( ulCount == 1 && pSelf->value.asList.pExprList->ExprType <= HB_ET_VARIABLE )
|
|
{
|
|
/* replace the list with a simple expression
|
|
* ( EXPR ) -> EXPR
|
|
*/
|
|
HB_EXPR_PTR pExpr = pSelf;
|
|
|
|
pSelf = pSelf->value.asList.pExprList;
|
|
pExpr->value.asList.pExprList = NULL;
|
|
hb_compExprFree( pExpr, HB_MACRO_PARAM );
|
|
}
|
|
}
|
|
return pSelf;
|
|
}
|
|
|
|
BOOL hb_compExprReduceAT( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
HB_EXPR_PTR pParms = pSelf->value.asFunCall.pParms;
|
|
HB_EXPR_PTR pSub = pParms->value.asList.pExprList;
|
|
HB_EXPR_PTR pText = pSub->pNext;
|
|
HB_EXPR_PTR pReduced;
|
|
|
|
if( pSub->ExprType == HB_ET_STRING && pText->ExprType == HB_ET_STRING )
|
|
{
|
|
if( pSub->value.asString.string[0] == '\0' )
|
|
{
|
|
pReduced = hb_compExprNewLong( 1 );
|
|
}
|
|
else
|
|
{
|
|
pReduced = hb_compExprNewLong( hb_strAt( pSub->value.asString.string, pSub->ulLength, pText->value.asString.string, pText->ulLength ) );
|
|
}
|
|
|
|
hb_compExprFree( pSelf->value.asFunCall.pFunName, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asFunCall.pParms, HB_MACRO_PARAM );
|
|
|
|
memcpy( pSelf, pReduced, sizeof( HB_EXPR ) );
|
|
hb_compExprClear( pReduced );
|
|
return TRUE;
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL hb_compExprReduceCHR( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
HB_EXPR_PTR pParms = pSelf->value.asFunCall.pParms;
|
|
HB_EXPR_PTR pArg = pParms->value.asList.pExprList;
|
|
HB_EXPR_PTR pExpr = NULL;
|
|
/* try to change it into a string */
|
|
|
|
if( pArg->ExprType == HB_ET_NUMERIC )
|
|
{
|
|
/* NOTE: CA-Cl*pper's compiler optimizer will be wrong for those
|
|
CHR() cases where the passed parameter is a constant which
|
|
can be divided by 256 but it's not zero, in this case it
|
|
will return an empty string instead of a Chr(0). [vszakats] */
|
|
|
|
pExpr = hb_compExprNew( HB_ET_STRING );
|
|
pExpr->ValType = HB_EV_STRING;
|
|
if( pArg->value.asNum.NumType == HB_ET_LONG )
|
|
{
|
|
BYTE bVal;
|
|
bVal = ( pArg->value.asNum.lVal % 256 );
|
|
|
|
if( bVal == 0 && pArg->value.asNum.lVal != 0 )
|
|
{
|
|
pExpr->value.asString.string = ( char * ) hb_xgrab( 1 );
|
|
pExpr->value.asString.string[ 0 ] = '\0';
|
|
pExpr->value.asString.dealloc = TRUE;
|
|
pExpr->ulLength = 0;
|
|
}
|
|
else
|
|
{
|
|
pExpr->value.asString.string = ( char * ) hb_xgrab( 2 );
|
|
pExpr->value.asString.string[ 0 ] = bVal;
|
|
pExpr->value.asString.string[ 1 ] = '\0';
|
|
pExpr->value.asString.dealloc = TRUE;
|
|
pExpr->ulLength = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pExpr->value.asString.string = ( char * ) hb_xgrab( 2 );
|
|
pExpr->value.asString.string[ 0 ] = ( ( unsigned int ) pArg->value.asNum.dVal % 256 );
|
|
pExpr->value.asString.string[ 1 ] = '\0';
|
|
pExpr->value.asString.dealloc = TRUE;
|
|
pExpr->ulLength = 1;
|
|
}
|
|
|
|
hb_compExprFree( pParms, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asFunCall.pFunName, HB_MACRO_PARAM );
|
|
memcpy( pSelf, pExpr, sizeof( HB_EXPR ) );
|
|
hb_compExprClear( pExpr );
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL hb_compExprReduceLEN( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
HB_EXPR_PTR pParms = pSelf->value.asFunCall.pParms;
|
|
HB_EXPR_PTR pArg = pParms->value.asList.pExprList;
|
|
|
|
if( pArg->ExprType == HB_ET_STRING || pArg->ExprType == HB_ET_ARRAY )
|
|
{
|
|
HB_EXPR_PTR pExpr = hb_compExprNewLong( pArg->ulLength );
|
|
|
|
hb_compExprFree( pParms, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asFunCall.pFunName, HB_MACRO_PARAM );
|
|
memcpy( pSelf, pExpr, sizeof( HB_EXPR ) );
|
|
hb_compExprClear( pExpr );
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL hb_compExprReduceASC( HB_EXPR_PTR pSelf, HB_MACRO_DECL )
|
|
{
|
|
HB_EXPR_PTR pParms = pSelf->value.asFunCall.pParms;
|
|
HB_EXPR_PTR pArg = pParms->value.asList.pExprList;
|
|
|
|
if( pArg->ExprType == HB_ET_STRING )
|
|
{
|
|
HB_EXPR_PTR pExpr = hb_compExprNewLong( pArg->value.asString.string[0] );
|
|
|
|
hb_compExprFree( pParms, HB_MACRO_PARAM );
|
|
hb_compExprFree( pSelf->value.asFunCall.pFunName, HB_MACRO_PARAM );
|
|
memcpy( pSelf, pExpr, sizeof( HB_EXPR ) );
|
|
hb_compExprClear( pExpr );
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|