root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cb/source/e4functi.c
alex 3d6c8b3e2d Patch level : 2.0 464 
Files correlati     : cb6.dll
Ricompilazione Demo : [ ]
Commento            :
Modifiche per la compilazione Linux


git-svn-id: svn://10.65.10.50/trunk@11080 c028cbd2-c16b-5b4b-a496-9718f37d4682
2003-05-01 15:14:58 +00:00

1318 lines
36 KiB
C
Executable File
Raw Blame History

/* e4functi.c (c)Copyright Sequiter Software Inc., 1988-1996. All rights reserved. */
#include "d4all.h"
#ifndef S4UNIX
#ifdef __TURBOC__
#pragma hdrstop
#endif
#endif
#ifndef S4NO_POW
#include <math.h>
#endif
#ifndef S4OFF_REPORT
double S4FUNCTION total4value( TOTAL4 *t4 );
#endif
E4FUNCTIONS v4functions[EXPR4NUM_FUNCTIONS] =
{
/* function, name, code, nameLen, priority, returnType, numParms, type[]*/
{ e4fieldAdd, 0, 0, 0, 0, r4str, 0, 0, 0, 0 }, /* E4FIELD_STR */
{ e4fieldCopy, 0, 1, 0, 0, r4str, 0, 0, 0, 0 }, /* E4FIELD_STR_CAT */
{ e4fieldLog, 0, 2, 0, 0, r4log, 0, 0, 0, 0 }, /* E4FIELD_LOG */
{ e4fieldDateD, 0, 3, 0, 0, r4dateDoub, 0, 0, 0, 0 }, /* E4FIELD_DATE_D */
{ e4fieldAdd, 0, 4, 0, 0, r4date, 0, 0, 0, 0 }, /* E4FIELD_DATE_S */
{ e4fieldNumD, 0, 5, 0, 0, r4numDoub, 0, 0, 0, 0 }, /* E4FIELD_NUM_D */
{ e4fieldAdd, 0, 6, 0, 0, r4num, 0, 0, 0, 0 }, /* E4FIELD_NUM_S */
#ifdef S4CLIENT_OR_FOX
{ e4fieldAdd, 0, 440, 0, 0, r4currency, 0, 0, 0, 0 }, /* E4FIELD_CUR */
{ e4fieldAdd, 0, 441, 0, 0, r4numDoub, 0, 0, 0, 0 }, /* E4FIELD_DOUB */
{ e4fieldAdd, 0, 442, 0, 0, r4int, 0, 0, 0, 0 }, /* E4FIELD_INT */
{ e4fieldAdd, 0, 443, 0, 0, r4dateTime, 0, 0, 0, 0 }, /* E4FIELD_DTTIME */
{ e4fieldIntD, 0, 444, 0, 0, r4numDoub, 0, 0, 0, 0 }, /* E4FIELD_INT_D */
{ e4fieldCurD, 0, 445, 0, 0, r4numDoub, 0, 0, 0, 0 }, /* E4FIELD_CUR_D */
#else
{ 0, 0, 440, 0, 0, r4currency, 0, 0, 0, 0 }, /* E4FIELD_CUR */
{ 0, 0, 441, 0, 0, r4numDoub, 0, 0, 0, 0 }, /* E4FIELD_DOUB */
{ 0, 0, 442, 0, 0, r4int, 0, 0, 0, 0 }, /* E4FIELD_INT */
{ 0, 0, 443, 0, 0, r4dateTime, 0, 0, 0, 0 }, /* E4FIELD_DTTIME */
{ 0, 0, 444, 0, 0, r4numDoub, 0, 0, 0, 0 }, /* E4FIELD_INT_D */
{ 0, 0, 445, 0, 0, r4numDoub, 0, 0, 0, 0 }, /* E4FIELD_CUR_D */
#endif
/* *** E4LAST_FIELD IS SET TO SAME VALUE AS E4FIELD_MEMO,
THIS MEANS ALL NEW FIELD ADDITIONS MUST GO BEFORE THIS COMMENT LINE
*/
#ifdef S4OFF_MEMO
{ 0, 0, 7, 0, 0, r4str, 0, 0, 0, 0 },
#else
{ e4fieldMemo, 0, 7, 0, 0, r4str, 0, 0, 0, 0 }, /* E4FIELD_MEMO */
#endif
{ e4copyConstant, 0, 8, 0, 0, r4numDoub, 0, 0, 0, 0 }, /* E4DOUBLE */
{ e4copyConstant, 0, 9, 0, 0, r4str, 0, 0, 0, 0 }, /* E4STRING */
/* E4FIRST_LOG STARTS AT E4LAST_FIELD + 4 (i.e. after copy constants) */
{ expr4trueFunction, ".TRUE.", 14, 6, 0, r4log, 0, 0, 0, 0 },
{ expr4trueFunction, ".T.", 14, 3, 0, r4log, 0, 0, 0, 0 },
{ e4false, ".FALSE.", 16, 7, 0, r4log, 0, 0, 0, 0 },
{ e4false, ".F.", 16, 3, 0, r4log, 0, 0, 0, 0 },
{ e4not, ".NOT.", 18, 5, 5, r4log, 1, r4log, 0, 0 },
/* E4LAST_LOG IS SET AT E4FIRST_LOG + 4 (since inclusive 10 to 14 = 5) */
/* E4FIRST_OPERATOR IS SET AT E4LAST_LOG + 1 */
/* E4LAST_OPERATOR IS SET AT E4FIRST_OPERATOR + 50 (51 entries less one for exclusive) */
{ e4or, ".OR.", 20, 4, 3, r4log, -1, r4log, 0, 0 }, /* Flexible # of parms.*/
{ e4and, ".AND.", 22, 5, 4, r4log, -1, r4log, 0, 0 },
{ e4parmRemove, "+", 25, 1, 7, r4str, 2, r4str, r4str, 0 }, /* Concatenate */
{ e4concatTrim, 0, 25, 0, 7, r4str, 2, r4str, r4str, 0 }, /* Concatenate */
{ e4add, 0, 25, 0, 7, r4numDoub, 2, r4numDoub, r4numDoub, 0 },
{ e4addDate, 0, 25, 0, 7, r4dateDoub, 2, r4numDoub, r4dateDoub, 0 },
{ e4addDate, 0, 25, 0, 7, r4dateDoub, 2, r4dateDoub,r4numDoub, 0 },
{ e4concatTwo, "-", 30, 1, 7, r4str, 2, r4str, r4str, 0 },
{ e4sub, 0, 30, 0, 7, r4numDoub, 2, r4numDoub, r4numDoub, 0 },
{ e4subDate, 0, 30, 0, 7, r4numDoub, 2, r4dateDoub, r4dateDoub, 0 },
{ e4subDate, 0, 30, 0, 7, r4dateDoub, 2, r4dateDoub, r4numDoub, 0 },
/* E4COMPARE_START IS E4FIRST_OPEATOR + 11 */
{ e4notEqual, "#", 50, 1, 6, r4log, 2, r4str, r4str, 0 },
{ e4notEqual, "<>", 50, 2, 6, r4log, 2, r4str, r4str, 0 },
{ e4notEqual, 0, 50, 0, 6, r4log, 2, r4numDoub, r4numDoub, 0 },
{ e4notEqual, 0, 50, 0, 6, r4log, 2, r4dateDoub, r4dateDoub, 0 },
{ e4notEqual, 0, 50, 0, 6, r4log, 2, r4log, r4log, 0 },
#ifdef S4CLIENT_OR_FOX
{ e4notEqualCur, 0, 50, 0, 6, r4log, 2, r4currency, r4currency, 0 },
{ e4notEqualDtTime, 0, 50, 0, 6, r4log, 2, r4dateTime, r4dateTime, 0 },
#else
{ 0, 0, 50, 0, 6, r4log, 2, r4currency, r4currency, 0 },
{ 0, 0, 50, 0, 6, r4log, 2, r4dateTime, r4dateTime, 0 },
#endif
{ e4greaterEq, ">=", 60, 2, 6, r4log, 2, r4str, r4str, 0 },
{ e4greaterEq, "=>", 60, 2, 6, r4log, 2, r4str, r4str, 0 },
{ e4greaterEqDoub, 0, 60, 0, 6, r4log, 2, r4numDoub, r4numDoub, 0 },
{ e4greaterEqDoub, 0, 60, 0, 6, r4log, 2, r4dateDoub, r4dateDoub, 0 },
#ifdef S4CLIENT_OR_FOX
{ e4greaterEqCur, 0, 60, 0, 6, r4log, 2, r4currency, r4currency, 0 },
{ e4greaterEqDtTime, 0, 60, 0, 6, r4log, 2, r4dateTime, r4dateTime, 0 },
#else
{ 0, 0, 60, 0, 6, r4log, 2, r4currency, r4currency, 0 },
{ 0, 0, 60, 0, 6, r4log, 2, r4dateTime, r4dateTime, 0 },
#endif
{ e4lessEq, "<=", 70, 2, 6, r4log, 2, r4str, r4str, 0 },
{ e4lessEq, "=<", 70, 2, 6, r4log, 2, r4str, r4str, 0 },
{ e4lessEqDoub, 0, 70, 0, 6, r4log, 2, r4numDoub, r4numDoub, 0 },
{ e4lessEqDoub, 0, 70, 0, 6, r4log, 2, r4dateDoub, r4dateDoub, 0 },
#ifdef S4CLIENT_OR_FOX
{ e4lessEqCur, 0, 70, 0, 6, r4log, 2, r4currency, r4currency, 0 },
{ e4lessEqDtTime, 0, 70, 0, 6, r4log, 2, r4dateTime, r4dateTime, 0 },
#else
{ 0, 0, 70, 0, 6, r4log, 2, r4currency, r4currency, 0 },
{ 0, 0, 70, 0, 6, r4log, 2, r4dateTime, r4dateTime, 0 },
#endif
{ e4equal, "=", 40, 1, 6, r4log, 2, r4str, r4str, 0 },
{ e4equal, 0, 40, 0, 6, r4log, 2, r4log, r4log, 0 },
{ e4equal, 0, 40, 0, 6, r4log, 2, r4numDoub, r4numDoub, 0 },
{ e4equal, 0, 40, 0, 6, r4log, 2, r4dateDoub, r4dateDoub, 0 },
#ifdef S4CLIENT_OR_FOX
{ e4equalCur, 0, 40, 0, 6, r4log, 2, r4currency, r4currency, 0 },
{ e4equalDtTime, 0, 40, 0, 6, r4log, 2, r4dateTime, r4dateTime, 0 },
#else
{ 0, 0, 40, 0, 6, r4log, 2, r4currency, r4currency, 0 },
{ 0, 0, 40, 0, 6, r4log, 2, r4dateTime, r4dateTime, 0 },
#endif
{ e4greater, ">", 80, 1, 6, r4log, 2, r4str, r4str, 0 },
{ e4greaterDoub, 0, 80, 0, 6, r4log, 2, r4numDoub, r4numDoub, 0 },
{ e4greaterDoub, 0, 80, 0, 6, r4log, 2, r4dateDoub, r4dateDoub, 0 },
#ifdef S4CLIENT_OR_FOX
{ e4greaterCur, 0, 80, 0, 6, r4log, 2, r4currency, r4currency, 0 },
{ e4greaterDtTime, 0, 80, 0, 6, r4log, 2, r4dateTime, r4dateTime, 0 },
#else
{ 0, 0, 80, 0, 6, r4log, 2, r4currency, r4currency, 0 },
{ 0, 0, 80, 0, 6, r4log, 2, r4dateTime, r4dateTime, 0 },
#endif
{ e4less, "<", 90, 1, 6, r4log, 2, r4str, r4str, 0 },
{ e4lessDoub, 0, 90, 0, 6, r4log, 2, r4numDoub, r4numDoub, 0 },
{ e4lessDoub, 0, 90, 0, 6, r4log, 2, r4dateDoub, r4dateDoub, 0 },
#ifdef S4CLIENT_OR_FOX
{ e4lessCur, 0, 90, 0, 6, r4log, 2, r4currency, r4currency, 0 },
{ e4lessDtTime, 0, 90, 0, 6, r4log, 2, r4dateTime, r4dateTime, 0 },
#else
{ 0, 0, 90, 0, 6, r4log, 2, r4currency, r4currency, 0 },
{ 0, 0, 90, 0, 6, r4log, 2, r4dateTime, r4dateTime, 0 },
#endif
/* E4COMPARE_END IS E4COMPARE_START + 34 */
#ifdef S4NO_POW
{ 0, 0, 95, 0, 0, r4numDoub, 2, r4numDoub, 0, 0 },
{ 0, 0, 95, 0, 0, r4numDoub, 2, r4numDoub, 0, 0 },
#else
{ e4power, "^", 100, 1, 9, r4numDoub, 2, r4numDoub, r4numDoub, 0},
{ e4power, "**", 100, 2, 9, r4numDoub, 2, r4numDoub, r4numDoub, 0},
#endif
{ e4multiply, "*", 102, 1, 8, r4numDoub, 2, r4numDoub, r4numDoub, 0},
{ e4divide, "/", 105, 1, 8, r4numDoub, 2, r4numDoub, r4numDoub, 0},
{ e4contain, "$", 110, 1, 6, r4log, 2, r4str, r4str, 0 },
/* E4FIRST_FUNCTION IS E4COMPARE_END + 6 --> since compare_end was
inclusive, should be 1 more than above functions (which is 5) */
{ e4chr, "CHR", 120, 3, 0, r4str, 1, r4numDoub, 0, 0 },
{ e4del, "DEL", 130, 3, 0, r4str, 0, 0, 0, 0 },
{ e4str, "STR", 140, 3, 0, r4str, 1, r4numDoub, 0 },
{ e4substr, "SUBSTR",150, 6, 0, r4str, 1, r4str, 0 },
{ e4time, "TIME", 160, 4, 0, r4str, 0, 0, 0, 0 },
{ e4upper, "UPPER", 170, 5, 0, r4str, 1, r4str, 0, 0 },
{ e4copyParm,"DTOS",180, 4, 0, r4str, 1, r4date, 0, 0 },
{ e4dtosDoub, 0, 180, 0, 0, r4str, 1, r4dateDoub, 0, 0 },
{ e4dtoc, "DTOC",200, 4, 0, r4str, 1, r4date, 0, 0 },
{ e4dtocDoub, 0,200, 4, 0, r4str, 1, r4dateDoub, 0, 0},
{ e4trim, "TRIM",220, 4, 0, r4str, 1, r4str, 0, 0 },
{ e4ltrim, "LTRIM",230, 5, 0, r4str, 1, r4str, 0, 0 },
{ e4alltrim, "ALLTRIM",235, 7, 0, r4str, 1, r4str, 0, 0 },
{ e4substr, "LEFT",240, 4, 0, r4str, 1, r4str, 0, 0 },
{ e4substr, "RIGHT",245, 5, 0, r4str, 1, r4str, 0, 0 },
{ e4iif, "IIF", 250, 3, 0, r4str, 3, r4log, r4str, r4str },
{ e4iif, 0, 250, 0, 0, r4numDoub, 3, r4log, r4numDoub, r4numDoub},
{ e4iif, 0, 250, 0, 0, r4dateDoub, 3, r4log, r4dateDoub, r4dateDoub},
{ e4iif, 0, 250, 0, 0, r4log, 3, r4log, r4log, r4log },
{ e4stod, "STOD", 260, 4, 0, r4dateDoub, 1, r4str, 0, 0 },
{ e4ctod, "CTOD", 270, 4, 0, r4dateDoub, 1, r4str, 0, 0 },
{ e4date, "DATE", 280, 4, 0, r4dateDoub, 0, 0, 0, 0 },
{ e4day, "DAY", 290, 3, 0, r4numDoub, 1, r4date, 0, 0 },
{ e4dayDoub, 0, 290, 0, 0, r4numDoub, 1, r4dateDoub, 0, 0 },
{ e4month, "MONTH", 310, 5, 0, r4numDoub, 1, r4date, 0, 0 },
{ e4monthDoub, 0, 310, 0, 0, r4numDoub, 1, r4dateDoub },
{ e4year, "YEAR", 340, 4, 0, r4numDoub, 1, r4date, 0, 0 },
{ e4yearDoub, 0, 340, 0, 0, r4numDoub, 1, r4dateDoub, 0, 0 },
{ e4deleted, "DELETED", 350, 7, 0, r4log, 0, 0, 0, 0 },
{ e4recCount, "RECCOUNT", 360, 8, 0, r4numDoub, 0, 0, 0, 0 },
{ e4recno, "RECNO", 370, 5, 0, r4numDoub, 0, 0, 0, 0 },
{ e4val, "VAL", 380, 3, 0, r4numDoub, 1, r4str, 0, 0 },
{ e4calcFunction, 0, 390, 0, 0, 0, 0, 0, 0, 0 },
#ifndef S4OFF_REPORT
/* { e4calcFunction, 0, 390, 0, 0, 0, 0, 0, 0, 0 },*/
{ e4calcTotal, 0, 400, 0, 0, r4numDoub, 0, 0, 0, 0 },
{ e4pageno, "PAGENO", 410, 6, 0, r4numDoub, 0, 0, 0, 0 },
#else
/* { 0, 0, 390, 0, 0, 0, 0, 0, 0, 0 },*/
{ 0, 0, 400, 0, 0, r4numDoub, 0, 0, 0, 0 },
{ 0, 0, 410, 6, 0, r4numDoub, 0, 0, 0, 0 },
#endif
/* DESCEND() only works like Clipper with Char parameter. */
{ e4descend, "DESCEND", 420, 7, 0, r4str, 1, r4str, 0, 0 },
{ e4descend, 0, 420, 7, 0, r4str, 1, r4num, 0, 0 },
{ e4descend, 0, 420, 7, 0, r4str, 1, r4date, 0, 0 },
{ e4descend, 0, 420, 7, 0, r4str, 1, r4dateDoub,0, 0 },
{ e4descend, 0, 420, 7, 0, r4str, 1, r4log, 0, 0 },
#ifdef S4CLIENT_OR_FOX
{ e4descend, 0, 420, 7, 0, r4str, 1, r4numDoub, 0, 0 },
{ e4descend, 0, 420, 7, 0, r4str, 1, r4dateTime, 0, 0 },
#else
{ 0, 0, 420, 7, 0, r4str, 1, r4numDoub, 0, 0 },
{ 0, 0, 420, 7, 0, r4str, 1, r4dateTime, 0, 0 },
#endif
{ e4ascend, "ASCEND", 430, 6, 0, r4str, 1, r4str, 0, 0 },
{ e4ascend, 0, 430, 6, 0, r4str, 1, r4num, 0, 0 },
{ e4ascend, 0, 430, 6, 0, r4str, 1, r4date, 0, 0 },
{ e4ascend, 0, 430, 6, 0, r4str, 1, r4dateDoub,0, 0 },
{ e4ascend, 0, 430, 6, 0, r4str, 1, r4log, 0, 0 },
#ifdef S4CLIENT_OR_FOX
{ e4ascend, 0, 430, 6, 0, r4str, 1, r4numDoub, 0, 0 },
{ e4ascend, 0, 430, 6, 0, r4str, 1, r4dateTime, 0, 0 },
#else
{ 0, 0, 430, 6, 0, r4str, 1, r4numDoub, 0, 0 },
{ 0, 0, 430, 6, 0, r4str, 1, r4dateTime, 0, 0 },
#endif
{ 0,0,-1, 0, 0, 0, 0, 0, 0, 0 },
} ;
void S4FUNCTION expr4functions( E4FUNCTIONS **fptr )
{
*fptr = v4functions ;
}
void e4add()
{
#ifdef S4DATA_ALIG2
double a,b,c;
#endif
double *doublePptr = (double *) (expr4buf + expr4infoPtr->resultPos) ;
#ifdef S4DATA_ALIG2
memcpy(&a, expr4[-2], sizeof(double));
memcpy(&b, expr4[-1], sizeof(double));
c = a + b;
memcpy(doublePptr, &c, sizeof(double));
#else
*doublePptr = *(double *)expr4[-2] + *(double *)expr4[-1] ;
#endif
expr4[-2] = (char *) doublePptr ;
expr4-- ;
}
void e4addDate()
{
if ( v4functions[expr4infoPtr->functionI].type[0] == r4dateDoub )
{
if ( *(double *)expr4[-2] == 0.0 )
{
*(double *)expr4-- = 0.0 ;
return ;
}
}
else
{
if ( *(double *)expr4[-1] == 0.0 )
{
*(double *)expr4-- = 0.0 ;
return ;
}
}
e4add() ;
}
void e4and()
{
int i ;
expr4 -= expr4infoPtr->numParms ;
for( i = expr4infoPtr->numParms-1 ; i > 0 ; i-- )
*(int *) expr4[0] = * (int *) expr4[i] && * (int *) expr4[0] ;
expr4++ ;
}
/* The total length of the result is in 'expr4infoPtr->len'. */
void e4concatSpecial( char movePchar )
{
int lenTwo, numChars, pos, firstLen ;
char *ptr ;
firstLen = expr4infoPtr[-expr4infoPtr[-1].numEntries-1].len ;
ptr = expr4[-2] ;
for ( pos = firstLen-1; pos >= 0; pos-- )
if ( ptr[pos] != movePchar )
break ;
if ( ++pos < firstLen )
{
lenTwo = expr4infoPtr->len - firstLen ;
c4memmove( ptr+ pos, expr4[-1], (unsigned int)lenTwo ) ;
numChars = firstLen - pos ;
memset( ptr+expr4infoPtr->len-numChars, movePchar, (unsigned int)numChars ) ;
}
expr4-- ;
}
void e4concatTrim()
{
e4concatSpecial(0) ;
}
void e4concatTwo()
{
e4concatSpecial(' ') ;
}
void e4contain()
{
int aLen, compLen, i, logResult ;
char firstChar, *bPtr ;
logResult = 0 ;
aLen = expr4infoPtr[-expr4infoPtr[-1].numEntries-1].len ;
firstChar = *expr4[-2] ;
compLen = expr4infoPtr[-1].len - aLen ;
bPtr = expr4[-1] ;
/* See if there is a match */
for ( i=0; i <= compLen; i++ )
if ( firstChar == bPtr[i] )
if ( u4memcmp( expr4[-2], bPtr+i, (size_t)aLen ) == 0 )
{
logResult = 1 ;
break ;
}
expr4[-2] = expr4buf + expr4infoPtr->resultPos ;
*(int *) expr4[-2] = logResult ;
expr4-- ;
}
void e4copyConstant()
{
void *ptr = *expr4++ = expr4buf+expr4infoPtr->resultPos ;
#ifdef E4ANALYZE
if ( ptr == 0 )
error4( 0, e4info, E80903 ) ;
#endif
memcpy( ptr, expr4constants+ expr4infoPtr->i1, (unsigned int)expr4infoPtr->len ) ;
}
void e4fieldCopy()
{
void *ptr = *expr4++ = expr4buf+expr4infoPtr->resultPos ;
#ifdef E4ANALYZE
if ( ptr == 0 )
error4( 0, e4info, E80903 ) ;
#endif
memcpy( ptr, *(char **)expr4infoPtr->p1 + expr4infoPtr->i1, (unsigned int)expr4infoPtr->len ) ;
}
void e4copyParm()
{
void *ptr = expr4[-1] ;
expr4[-1] = expr4buf + expr4infoPtr->resultPos ;
#ifdef E4ANALYZE
if ( ptr == 0 )
error4( 0, e4info, E80903 ) ;
#endif
memcpy( expr4[-1], ptr, (unsigned int)expr4infoPtr->len ) ;
}
void e4ctod()
{
char buf[8] ;
double d ;
date4init( buf, expr4[-1], expr4constants+ expr4infoPtr->i1 ) ;
expr4[-1] = expr4buf + expr4infoPtr->resultPos ;
d = date4long( buf ) ;
memcpy( expr4[-1], (void *)&d, sizeof(d) ) ;
}
void e4date()
{
char datePbuf[8] ;
date4today( datePbuf ) ;
*expr4++ = expr4buf + expr4infoPtr->resultPos ;
*((double *) expr4[-1]) = (double) date4long( datePbuf ) ;
}
void e4day()
{
double d ;
d = (double) date4day( expr4[-1] ) ;
expr4[-1] = expr4buf + expr4infoPtr->resultPos ;
*(double *) expr4[-1] = d ;
}
void e4dayDoub()
{
char datePbuf[8] ;
date4assign( datePbuf, (long) *(double *)expr4[-1] ) ;
expr4[-1] = expr4buf + expr4infoPtr->resultPos ;
*(double *) expr4[-1] = (double) date4day( datePbuf ) ;
}
void e4del()
{
expr4[0] = expr4buf + expr4infoPtr->resultPos ;
expr4[0][0] = *( *(char **)expr4infoPtr->p1) ;
expr4++ ;
}
void e4deleted()
{
int result = 0 ;
#ifdef E4MISC
if ( *( *(char **)expr4infoPtr->p1 ) != '*' && *( *(char **)expr4infoPtr->p1 ) != ' ' )
error4( 0, e4info, E80907 ) ;
#endif
if ( *( *(char **)expr4infoPtr->p1 ) == '*' )
result = 1 ;
*(int *) (*expr4++ = expr4buf + expr4infoPtr->resultPos ) = result ;
}
void e4divide()
{
double doub, *resultPtr ;
resultPtr = (double *) (expr4buf + expr4infoPtr->resultPos) ;
memcpy( (void *)&doub, (void *)expr4[-1], sizeof(double ) ) ;
if ( doub == 0.0 )
*resultPtr = 0.0 ;
else
*resultPtr = *(double *)expr4[-2] / *(double *) expr4[-1] ;
expr4[-2] = (char *) resultPtr ;
expr4-- ;
}
void e4dtoc()
{
char buf[LEN4DATE_FORMAT] ;
date4format( expr4[-1], buf, expr4constants+ expr4infoPtr->i1 ) ;
expr4[-1] = expr4buf + expr4infoPtr->resultPos ;
memcpy( expr4[-1], buf, (unsigned int)expr4infoPtr->len ) ;
}
void e4dtocDoub()
{
e4dtosDoub() ;
e4dtoc() ;
}
void e4chr()
{
double doub ;
memcpy( (void *) &doub, (void *) expr4[-1], sizeof(double) ) ;
*expr4[-1] = (char) doub ;
}
void e4dtosDoub()
{
date4assign( expr4buf + expr4infoPtr->resultPos, (long) *(double *) expr4[-1] ) ;
expr4[-1] = expr4buf + expr4infoPtr->resultPos ;
}
#ifdef S4CLIENT_OR_FOX
void e4equalCur()
{
int *intPtr ;
intPtr = (int *)(expr4buf + expr4infoPtr->resultPos) ;
*intPtr = !currency4compare( (CURRENCY4 *)expr4[-2], (CURRENCY4 *)expr4[-1] ) ;
expr4[-2] = (char *)intPtr ;
expr4-- ;
}
void e4equalDtTime()
{
int *intPtr ;
intPtr = (int *)(expr4buf + expr4infoPtr->resultPos) ;
*intPtr = !date4timeCompare( (long *)expr4[-2], (long *)expr4[-1] ) ;
expr4[-2] = (char *)intPtr ;
expr4-- ;
}
#endif /* S4CLIENT_OR_FOX */
void e4equal()
{
int *intPtr ;
intPtr = (int *)(expr4buf + expr4infoPtr->resultPos) ;
*intPtr = !u4memcmp( expr4[-2], expr4[-1], (unsigned int)expr4infoPtr->i1 ) ;
expr4[-2] = (char *)intPtr ;
expr4-- ;
}
void e4false()
{
int *ptr ;
ptr = (int *) (*expr4++ = expr4buf+expr4infoPtr->resultPos) ;
*ptr = 0 ;
}
void e4fieldDateD()
{
void *ptr = *expr4++ = expr4buf+expr4infoPtr->resultPos ;
double d = date4long( *(char **)expr4infoPtr->p1 + expr4infoPtr->i1 ) ;
#ifdef E4ANALYZE
if ( ptr == 0 )
error4( 0, e4info, E80903 ) ;
#endif
memcpy( ptr, (void *)&d, sizeof(d) ) ;
}
void e4fieldLog()
{
int *ptr = (int *) (*expr4++ = expr4buf+expr4infoPtr->resultPos) ;
char charValue = *(* (char **)expr4infoPtr->p1 + expr4infoPtr->i1 ) ;
if ( charValue == 'Y' || charValue == 'y' ||
charValue == 'T' || charValue == 't' )
*ptr = 1 ;
else
*ptr = 0 ;
}
#ifndef S4OFF_MEMO
void e4fieldMemo()
{
char *ptr, *memoPtr ;
unsigned memoLen, copyLen, zeroLen ;
ptr = *expr4++ = expr4buf + expr4infoPtr->resultPos ;
/* memoLen = f4memoLen( d4fieldJ( expr4ptr->data, expr4infoPtr->fieldNo ) ) ;*/
/* memoPtr = f4memoPtr( d4fieldJ( expr4ptr->data, expr4infoPtr->fieldNo ) ) ;*/
memoLen = f4memoLen( expr4infoPtr->fieldPtr ) ;
memoPtr = f4memoPtr( expr4infoPtr->fieldPtr ) ;
if( error4code( expr4ptr->codeBase ) < 0 )
return ;
copyLen = memoLen ;
zeroLen = 0 ;
if( copyLen > (unsigned) expr4infoPtr->len )
copyLen = (unsigned int)expr4infoPtr->len ;
else
zeroLen = expr4infoPtr->len - copyLen ;
#ifdef E4ANALYZE
if ( ptr == 0 )
error4( 0, e4info, E80903 ) ;
#endif
memcpy( ptr, memoPtr, copyLen ) ;
memset( ptr + copyLen, 0, zeroLen ) ;
}
#endif
#ifdef S4CLIENT_OR_FOX
void e4fieldCurD()
{
void *ptr ;
double d ;
CURRENCY4 *val ;
char currencyBuffer[21] ;
ptr = *expr4++ = expr4buf + expr4infoPtr->resultPos ;
val = ((CURRENCY4 *)( *(char **)expr4infoPtr->p1 + expr4infoPtr->i1 ) ) ;
/*
this algorithm produces values which might be off at the last point
of double precision (comparet to string calculations), so instead
the slower string conversion routines were inserted */
/*
d = val->lo[3] ;
d = d * 65536 + (double)val->lo[2] ;
d = d * 65536 + (double)val->lo[1] ;
d = d * 65536 + (double)val->lo[0] ;
d /= 10000.0 ;
*/
memset( currencyBuffer, 0, sizeof( currencyBuffer ) ) ;
c4currencyToA( currencyBuffer, sizeof( currencyBuffer ), val, 4 ) ;
d = c4atod( currencyBuffer, strlen( currencyBuffer ) ) ;
#ifdef E4ANALYZE
if ( ptr == 0 )
error4( 0, e4info, E80903 ) ;
#endif
memcpy( ptr, (void *)&d, sizeof(d) ) ;
}
#endif /* S4CLIENT_OR_FOX */
void e4fieldIntD()
{
void *ptr ;
double d ;
long val ;
ptr = *expr4++ = expr4buf + expr4infoPtr->resultPos ;
val = *((long *)( *(char **)expr4infoPtr->p1 + expr4infoPtr->i1 ) ) ;
d = (double)val ;
#ifdef E4ANALYZE
if ( ptr == 0 )
error4( 0, e4info, E80903 ) ;
#endif
memcpy( ptr, (void *)&d, sizeof(d) ) ;
}
void e4fieldNumD()
{
void *ptr ;
double d ;
ptr = *expr4++ = expr4buf + expr4infoPtr->resultPos ;
d = c4atod( *(char **)expr4infoPtr->p1 + expr4infoPtr->i1, expr4infoPtr->len ) ;
#ifdef E4ANALYZE
if ( ptr == 0 )
error4( 0, e4info, E80903 ) ;
#endif
memcpy( ptr, (void *)&d, sizeof(d) ) ;
}
#ifdef S4CLIENT_OR_FOX
void e4greaterCur()
{
int *intPtr, rc ;
intPtr = (int *)(expr4buf + expr4infoPtr->resultPos) ;
rc = currency4compare( (CURRENCY4 *)expr4[-2], (CURRENCY4 *)expr4[-1] ) ;
if( rc > 0 )
*intPtr = 1 ;
else
{
if( rc < 0 )
*intPtr = 0 ;
else
*intPtr = (int)((long)expr4infoPtr->p1) ;
}
expr4[-2] = (char *) intPtr ;
expr4-- ;
}
void e4greaterDtTime()
{
int *intPtr, rc ;
intPtr = (int *)(expr4buf + expr4infoPtr->resultPos) ;
rc = date4timeCompare( (long *)expr4[-2], (long *)expr4[-1] ) ;
if( rc > 0 )
*intPtr = 1 ;
else
{
if( rc < 0 )
*intPtr = 0 ;
else
*intPtr = (int)((long)expr4infoPtr->p1) ;
}
expr4[-2] = (char *) intPtr ;
expr4-- ;
}
#endif /* S4CLIENT_OR_FOX */
void e4greater()
{
int *intPtr, rc ;
intPtr = (int *)(expr4buf + expr4infoPtr->resultPos) ;
rc = u4memcmp( expr4[-2], expr4[-1], (unsigned int)expr4infoPtr->i1 ) ;
if( rc > 0 )
*intPtr = 1 ;
else
{
if( rc < 0 )
*intPtr = 0 ;
else
*intPtr = (int)((long)expr4infoPtr->p1) ;
}
expr4[-2] = (char *) intPtr ;
expr4-- ;
}
void e4greaterDoub()
{
e4lessEqDoub() ;
*(int *)expr4[-1] = ! *(int *)expr4[-1] ;
}
#ifdef S4CLIENT_OR_FOX
void e4greaterEqCur()
{
e4lessCur() ;
*((int *)expr4[-1]) = ! *((int *)expr4[-1]) ;
}
void e4greaterEqDtTime()
{
e4lessDtTime() ;
*((int *)expr4[-1]) = ! *((int *)expr4[-1]) ;
}
#endif /* S4CLIENT_OR_FOX */
void e4greaterEq()
{
e4less() ;
*((int *)expr4[-1]) = ! *((int *)expr4[-1]) ;
}
void e4greaterEqDoub()
{
int *intPtr ;
#ifdef S4DATA_ALIG2
double a,b;
#endif
intPtr = (int *)(expr4buf + expr4infoPtr->resultPos) ;
#ifdef S4DATA_ALIG2
memcpy(&a, (double *)expr4[-2], sizeof(double));
memcpy(&b, (double *)expr4[-1], sizeof(double));
if (a>=b)
#else
if ( *(double *)expr4[-2] >= *(double *)expr4[-1] )
#endif /* !S4DATA_ALIG2 */
*intPtr = 1 ;
else
*intPtr = 0 ;
expr4[-2] = (char *) intPtr ;
expr4-- ;
}
void e4iif()
{
if ( *(int *) expr4[-3] )
c4memmove( expr4buf + expr4infoPtr->resultPos, expr4[-2], (unsigned int)expr4infoPtr->len ) ;
else
c4memmove( expr4buf + expr4infoPtr->resultPos, expr4[-1], (unsigned int)expr4infoPtr->len ) ;
expr4[-3] = expr4buf + expr4infoPtr->resultPos ;
expr4-= 2 ;
}
#ifdef S4CLIENT_OR_FOX
void e4lessCur()
{
int *intPtr, rc ;
intPtr = (int *)(expr4buf + expr4infoPtr->resultPos) ;
rc = currency4compare( (CURRENCY4 *)expr4[-2], (CURRENCY4 *)expr4[-1] ) ;
if( rc < 0 )
*intPtr = 1 ;
else
{
if( rc > 0 )
*intPtr = 0 ;
else
*intPtr = (int)((long)expr4infoPtr->p1) ;
}
expr4[-2] = (char *)intPtr ;
expr4-- ;
}
void e4lessDtTime()
{
int *intPtr, rc ;
intPtr = (int *)(expr4buf + expr4infoPtr->resultPos) ;
rc = date4timeCompare( (long *)expr4[-2], (long *)expr4[-1] ) ;
if( rc < 0 )
*intPtr = 1 ;
else
{
if( rc > 0 )
*intPtr = 0 ;
else
*intPtr = (int)((long)expr4infoPtr->p1) ;
}
expr4[-2] = (char *)intPtr ;
expr4-- ;
}
#endif /* S4CLIENT_OR_FOX */
void e4less()
{
int *intPtr, rc ;
intPtr = (int *)(expr4buf + expr4infoPtr->resultPos) ;
rc = u4memcmp( expr4[-2], expr4[-1], (unsigned int)expr4infoPtr->i1 ) ;
if( rc < 0 )
*intPtr = 1 ;
else
{
if( rc > 0 )
*intPtr = 0 ;
else
*intPtr = (int)((long)expr4infoPtr->p1) ;
}
expr4[-2] = (char *)intPtr ;
expr4-- ;
}
void e4lessDoub()
{
e4greaterEqDoub() ;
*(int *)expr4[-1] = ! *(int *)expr4[-1] ;
}
#ifdef S4CLIENT_OR_FOX
void e4lessEqCur()
{
e4greaterCur() ;
*((int *)expr4[-1]) = ! *((int *)expr4[-1]) ;
}
void e4lessEqDtTime()
{
e4greaterDtTime() ;
*((int *)expr4[-1]) = ! *((int *)expr4[-1]) ;
}
#endif /* S4CLIENT_OR_FOX */
void e4lessEq()
{
e4greater() ;
*((int *)expr4[-1]) = ! *((int *)expr4[-1]) ;
}
void e4lessEqDoub()
{
int *intPtr ;
#ifdef S4DATA_ALIG2
double doub1, doub2 ;
memcpy( (void *)&doub1, (void *)expr4[-2], sizeof(double) ) ;
memcpy( (void *)&doub2, (void *)expr4[-1], sizeof(double) ) ;
#endif
intPtr = (int *)(expr4buf + expr4infoPtr->resultPos) ;
#ifdef S4DATA_ALIG2
if ( doub1 <= doub2 )
#else
if ( *(double *)expr4[-2] <= *(double *)expr4[-1] )
#endif
*intPtr = 1 ;
else
*intPtr = 0 ;
expr4[-2] = (char *) intPtr ;
expr4-- ;
}
void e4ltrim()
{
int n ;
char *ptr ;
for( n = 0; n < expr4infoPtr->len; n++ )
if ( expr4[-1][n] != ' ' && expr4[-1][n] != 0 )
break ;
ptr = expr4buf + expr4infoPtr->resultPos ;
c4memmove( ptr, expr4[-1]+n, (unsigned int)(expr4infoPtr->len - n) ) ;
memset( ptr+ expr4infoPtr->len - n, 0, (unsigned int)n ) ;
expr4[-1] = ptr ;
}
void e4alltrim()
{
e4ltrim() ;
e4trim() ;
}
void e4month()
{
double *doublePptr = (double *)(expr4buf + expr4infoPtr->resultPos) ;
*doublePptr = (double)date4month( expr4[-1] ) ;
expr4[-1] = (char *) doublePptr ;
}
void e4monthDoub()
{
char datePbuf[8] ;
double *doublePptr ;
doublePptr = (double *) (expr4buf + expr4infoPtr->resultPos) ;
date4assign( datePbuf, (long) *(double *)expr4[-1] ) ;
*doublePptr = (double) date4month( datePbuf ) ;
expr4[-1] = (char *) doublePptr ;
}
void e4multiply()
{
double *doublePptr ;
doublePptr = (double *)(expr4buf + expr4infoPtr->resultPos) ;
*doublePptr = *(double *)expr4[-2] * *(double *)expr4[-1] ;
expr4[-2] = (char *) doublePptr ;
expr4-- ;
}
void e4nop()
{
}
void e4not()
{
int *ptr ;
ptr = (int *)expr4[-1] ;
*ptr = !*ptr ;
}
#ifdef S4CLIENT_OR_FOX
void e4notEqualCur()
{
int *intPtr ;
intPtr = (int *)(expr4buf + expr4infoPtr->resultPos) ;
*intPtr = currency4compare( (CURRENCY4 *)expr4[-2], (CURRENCY4 *)expr4[-1] ) ;
expr4[-2] = (char *) intPtr ;
expr4-- ;
}
void e4notEqualDtTime()
{
int *intPtr ;
intPtr = (int *)(expr4buf + expr4infoPtr->resultPos) ;
*intPtr = date4timeCompare( (long *)expr4[-2], (long *)expr4[-1] ) ;
expr4[-2] = (char *) intPtr ;
expr4-- ;
}
#endif /* S4CLIENT_OR_FOX */
void e4notEqual()
{
int *intPtr ;
intPtr = (int *)(expr4buf + expr4infoPtr->resultPos) ;
*intPtr = u4memcmp( expr4[-2], expr4[-1], (unsigned int)expr4infoPtr->i1 ) != 0 ? 1 : 0 ;
expr4[-2] = (char *) intPtr ;
expr4-- ;
}
void e4or()
{
int i ;
expr4 -= expr4infoPtr->numParms ;
for( i = expr4infoPtr->numParms-1 ; i > 0 ; i-- )
*(int *) expr4[0] = * (int *) expr4[i] || * (int *) expr4[0] ;
expr4++ ;
}
void e4fieldAdd()
{
*expr4++ = *(char **)expr4infoPtr->p1 + expr4infoPtr->i1 ;
}
void e4parmRemove()
{
expr4-- ;
}
#ifndef S4NO_POW
void e4power()
{
double *doublePptr ;
#ifdef S4DATA_ALIG2
double doub1,doub2,doub3 ;
#endif
doublePptr = (double *) (expr4buf + expr4infoPtr->resultPos) ;
#ifdef S4DATA_ALIG2
memcpy( &doub2, expr4[-2], sizeof(double) ) ;
memcpy( &doub1, expr4[-1], sizeof(double) ) ;
doub3 = pow( doub2, doub1 ) ;
memcpy( doublePptr, &doub3, sizeof(double) ) ;
#else
*doublePptr = pow( *(double *) expr4[-2], *(double *) expr4[-1] ) ;
#endif
expr4[-2] = (char *) doublePptr ;
expr4-- ;
}
#endif
void e4recCount()
{
double d ;
long serverId = -2L ;
DATA4FILE *dataFile ;
#ifdef S4SERVER
DATA4 *data ;
LIST4 *dataList ;
#endif
dataFile = (DATA4FILE *)expr4infoPtr->p1 ;
#ifdef S4SERVER
/* need to get a DATA4 corresponding to the data4file for the current
client, in order to determine the context, which may affect the current
record count for the data file due to transactions */
dataList = tran4dataList( code4trans( dataFile->c4 ) ) ;
for ( data = 0 ;; )
{
data = (DATA4 *)l4next( dataList, data ) ;
if ( data == 0 )
{
serverId = -1 ; /* get non-trans count */
break ;
}
if ( data->dataFile == dataFile )
{
serverId = data4serverId( data ) ;
break ;
}
}
#endif
d = (double)dfile4recCount( dataFile, serverId ) ;
memcpy( *expr4++ = expr4buf+ expr4infoPtr->resultPos, (void *)&d, sizeof(d) ) ;
}
void e4recno()
{
double d ;
d = (double)d4recNo( expr4ptr->data ) ; /* updated for c/s */
/* d = (double)d4recNo( (DATA4 *) expr4infoPtr->p1 ) ;*/
memcpy( *expr4++ = expr4buf+ expr4infoPtr->resultPos, (void *)&d, sizeof(d) ) ;
}
void e4stod()
{
double *doublePptr ;
#ifdef S4DATA_ALIG2
double a;
#endif
doublePptr = (double *)(expr4buf + expr4infoPtr->resultPos) ;
#ifdef S4DATA_ALIG2
a=(double)date4long(expr4[-1]);
memcpy(doublePptr, &a, sizeof(double));
#else
*doublePptr = (double) date4long( expr4[-1] ) ;
#endif /* !S4DATA_ALIG2 */
expr4[-1] = (char *) doublePptr ;
}
void e4str()
{
char *ptr ;
#ifdef S4DATA_ALIG2
double doub;
#endif
ptr = expr4buf + expr4infoPtr->resultPos ;
#ifdef S4DATA_ALIG2
memcpy( (void *)&doub, expr4[-1], sizeof(double) );
c4dtoa45( doub, ptr, expr4infoPtr->len, expr4infoPtr->i1 ) ;
#else
c4dtoa45( *(double *) expr4[-1], ptr, expr4infoPtr->len, expr4infoPtr->i1 ) ;
#endif
expr4[-1] = ptr ;
}
void e4sub()
{
double *doublePptr ;
#ifdef S4DATA_ALIG2
double a,b;
#endif
doublePptr = (double *)(expr4buf + expr4infoPtr->resultPos) ;
#ifdef S4DATA_ALIG2
memcpy(&a, expr4[-2], sizeof(double));
memcpy(&b, expr4[-1], sizeof(double));
*doublePptr = a-b;
#else
*doublePptr = *(double *)expr4[-2] - *(double *)expr4[-1] ;
#endif
expr4[-2] = (char *) doublePptr ;
expr4-- ;
}
void e4subDate()
{
if ( v4functions[expr4infoPtr->functionI].type[0] == r4dateDoub )
{
if ( *(double *)expr4[-2] == 0.0 )
{
*(double *)expr4-- = 0.0 ;
return ;
}
}
if ( v4functions[expr4infoPtr->functionI].type[1] == r4dateDoub )
{
if ( *(double *)expr4[-1] == 0.0 )
{
*(double *)expr4-- = 0.0 ;
return ;
}
}
e4sub() ;
}
void e4substr()
{
c4memmove( expr4buf + expr4infoPtr->resultPos, expr4buf + expr4infoPtr->resultPos + expr4infoPtr->i1, (unsigned int)expr4infoPtr->len ) ;
}
void e4time()
{
date4timeNow( *expr4++ = expr4buf + expr4infoPtr->resultPos ) ;
}
void e4trim()
{
c4trimN( expr4[-1], expr4infoPtr->len + 1 ) ;
}
void expr4trueFunction()
{
int *ptr ;
ptr = (int *)(*expr4++ = expr4buf+expr4infoPtr->resultPos) ;
*ptr = 1 ;
}
void e4upper()
{
expr4[-1][expr4infoPtr->len] = 0 ;
c4upper( expr4[-1] ) ;
}
void e4val()
{
char *ptr ;
double d ;
ptr = expr4buf + expr4infoPtr->resultPos ;
d = c4atod( expr4[-1], expr4infoPtr[-1].len ) ;
#ifdef E4ANALYZE
if ( ptr == 0 )
error4( 0, e4info, E80903 ) ;
#endif
memcpy( ptr, (void *)&d, sizeof(d) ) ;
expr4[-1] = (char *) ptr ;
}
void e4year()
{
double d ;
d = (double) date4year( expr4[-1] ) ;
expr4[-1] = expr4buf + expr4infoPtr->resultPos ;
*(double *)expr4[-1] = d ;
}
void e4yearDoub()
{
char datePbuf[8] ;
date4assign( datePbuf, (long) *(double *)expr4[-1] ) ;
expr4[-1] = expr4buf + expr4infoPtr->resultPos ;
*(double *) expr4[-1] = date4year( datePbuf ) ;
}
void e4ascend()
{
double d ;
char *ptr ;
/* modified 09/15/95 AS -- need to always perform ascend in the expression
buffer in case of concatanations */
ptr = expr4buf + expr4infoPtr->resultPos ;
if ( expr4[-1] != ptr )
{
memcpy( ptr, expr4[-1], expr4infoPtr->len ) ;
expr4[-1] = ptr ;
}
switch( v4functions[expr4infoPtr->functionI].type[0] )
{
case r4str:
break ;
case r4num:
c4clip( expr4[-1], expr4infoPtr->len ) ;
break ;
case r4dateDoub:
d = *(double *)expr4[-1] ;
date4assign( expr4[-1], (long)d ) ;
break ;
case r4log:
if( *(int *) expr4[-1] )
*expr4[-1] = '1' ;
else
*expr4[-1] = '0' ;
return ;
#ifdef S4FOX
case r4numDoub:
t4dblToFox( expr4[-1], *((double *)expr4[-1]) ) ; /* converts a double to an ordered byte */
return ;
case r4dateTime:
x4reverseLong( expr4[-1] ) ;
x4reverseLong( &(((long *)expr4[-1])[1]) ) ;
return ;
#endif
default:
break ;
}
}
void e4descend()
{
#ifdef S4FOX
int loop ;
#endif
e4ascend() ;
#ifdef S4FOX
if( v4functions[expr4infoPtr->functionI].type[0] == r4numDoub || v4functions[expr4infoPtr->functionI].type[0] == r4dateTime )
{
for ( loop = 0 ; loop < sizeof( double ) ; loop++ )
((char *)expr4[-1])[loop] = ~((char *)expr4[-1])[loop] ;
}
else
#endif
c4descend( expr4[-1], expr4[-1], expr4infoPtr->len ) ;
}
void e4calcFunction()
{
EXPR4CALC *e4calcPtr = (EXPR4CALC *) expr4infoPtr->p1 ;
char **e4save = expr4 ;
char *expr4constantsSave = expr4constants ;
char *resultPtr ;
expr4calcResultPos( e4calcPtr, expr4infoPtr->resultPos ) ;
expr4vary( e4calcPtr->expr, &resultPtr ) ;
expr4start( e4calcPtr->expr ) ; /* restart from vary */
expr4 = e4save ;
expr4constants = expr4constantsSave ;
*expr4++ = resultPtr ;
}
#ifndef S4OFF_REPORT
void e4pageno()
{
double d = (double) expr4ptr->codeBase->pageno ;
memcpy( *expr4++ = expr4buf + expr4infoPtr->resultPos, (void *)&d, sizeof(d) ) ;
}
void e4calcTotal()
{
double d = total4value( (struct TOTAL4st *) expr4infoPtr->p1 ) ;
*expr4 = expr4buf + expr4infoPtr->resultPos ;
memcpy( *expr4++, (void *)&d, sizeof(d) ) ;
}
double S4FUNCTION total4value( TOTAL4 *t4 )
{
switch( t4->totalType )
{
case total4sum:
return t4->total ;
case total4count:
return (double) t4->count ;
case total4average:
if( t4->count == 0 )
return 0.0 ;
return t4->total/t4->count ;
case total4highest:
return t4->high ;
case total4lowest:
return t4->low ;
default:
break ;
}
return t4->total ;
}
#endif
Reference in New Issue View Git Blame Copy Permalink