root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cb/source/f4field.c

1326 lines
30 KiB
C
Raw Normal View History

Codebase git-svn-id: svn://10.65.10.50/trunk@4679 c028cbd2-c16b-5b4b-a496-9718f37d4682
1997-06-16 13:01:08 +00:00
/* f4field.c (c)Copyright Sequiter Software Inc., 1988-1996. All rights reserved. */
#include "d4all.h"
#ifndef S4UNIX
#ifdef __TURBOC__
#pragma hdrstop
#endif
#endif
#ifndef S4OFF_WRITE
char *S4FUNCTION f4assignPtr( FIELD4 *field )
{
#ifdef E4PARM_HIGH
if ( field == 0 )
{
error4( 0, e4parm_null, E90507 ) ;
return 0 ;
}
#endif
#ifdef S4CLIENT_OR_FOX
if ( d4version( field->data ) == 0x30 )
f4assignNotNull( field ) ;
#endif
field->data->recordChanged = 1 ;
return ( field->data->record + field->offset ) ;
}
void S4FUNCTION f4blank( FIELD4 *field )
{
#ifdef S4VBASIC
if ( c4parm_check( (void *)field, 3, E90508 ) )
return ;
#endif
#ifdef E4PARM_HIGH
if ( field == 0 )
{
error4( 0, e4parm_null, E90508 ) ;
return ;
}
#endif
if ( error4code( field->data->codeBase ) < 0 )
return ;
#ifndef S4SERVER
#ifndef S4OFF_ENFORCE_LOCK
if ( field->data->codeBase->lockEnforce && field->data->recNum > 0L )
if ( d4lockTest( field->data, field->data->recNum ) != 1 )
{
error4( field->data->codeBase, e4lock, E90508 ) ;
return ;
}
#endif
#endif
#ifdef S4CLIENT_OR_FOX
if ( field->binary )
memset( f4assignPtr( field ), 0, field->len ) ;
else
#endif
memset( f4assignPtr( field ), ' ', field->len ) ;
}
#endif
DATA4 *S4FUNCTION f4data( const FIELD4 *field )
{
#ifdef E4PARM_HIGH
if ( field == 0 )
{
error4( 0, e4parm_null, E90509 ) ;
return 0 ;
}
#endif
return field->data ;
}
int S4FUNCTION f4decimals( const FIELD4 *field )
{
#ifdef S4VBASIC
if ( c4parm_check( (void *)field, 3, E90510 ) )
return -1 ;
#endif
#ifdef E4PARM_HIGH
if ( field == 0 )
return error4( 0, e4parm_null, E90510 ) ;
#endif
return field->dec ;
}
unsigned S4FUNCTION f4len( const FIELD4 *field )
{
#ifdef S4VBASIC
if ( c4parm_check( (void *)field, 3, E90511 ) )
return 0 ;
#endif
#ifdef E4PARM_HIGH
if ( field == 0 )
{
error4( 0, e4parm_null, E90511 ) ;
return 0 ;
}
#endif
return field->len ;
}
S4CONST char *S4FUNCTION f4name( S4CONST FIELD4 *field )
{
#ifdef S4VBASIC
if ( c4parm_check( (void *)field, 3, E90512 ) )
return 0 ;
#endif
#ifdef E4PARM_HIGH
if ( field == 0 )
{
error4( 0, e4parm_null, E90512 ) ;
return 0 ;
}
#endif
return field->name ;
}
int S4FUNCTION f4number( const FIELD4 *field )
{
FIELD4 *fieldOn ;
int fNum ;
#ifdef E4PARM_HIGH
if ( field == 0 )
return error4( 0, e4parm_null, E90538 ) ;
#endif
fieldOn = field->data->fields ;
for ( fNum = 1 ;; fNum++ )
{
if ( fieldOn == field )
return fNum ;
fieldOn++ ;
}
}
int S4FUNCTION f4type( const FIELD4 *field )
{
#ifdef S4VBASIC
if ( c4parm_check( (void *)field, 3, E90513 ) )
return -1 ;
#endif
#ifdef E4PARM_HIGH
if ( field == 0 )
return error4( 0, e4parm_null, E90513 ) ;
#endif
#ifdef S4CLIENT_OR_FOX
switch( field->type )
{
case 'F':
return (int)r4num ;
case 'C':
if ( field->binary )
return r4charBin ;
else
return r4str ;
case 'M':
if ( field->binary == 1 )
return r4memoBin ;
else
return r4memo ;
default:
return (int)field->type ;
}
#else
if ( field->type == 'F' )
return (int)r4num ;
else
return (int)field->type ;
#endif
}
#ifdef S4CLIENT_OR_FOX
static void negate( CURRENCY4 *, const CURRENCY4 * ) ;
static void shiftLeft( long *, long *, int ) ;
int S4FUNCTION date4timeCompare( const long *dt1, const long *dt2 )
{
long date1, date2, time1, time2 ;
date1 = dt1[0] ;
date2 = dt2[0] ;
if ( date1 == date2 ) /* must compare on times */
{
time1 = dt1[1] ;
time2 = dt2[1] ;
if ( time1 > time2 )
return 1 ;
if ( time1 < time2 )
return -1 ;
return 0 ;
}
else /* dates not equal */
{
if ( date1 > date2 )
return 1 ;
return -1 ;
}
}
/* returns -1 if c1 < c2, 0 if equal, 1 if c1 > c2 */
int S4FUNCTION currency4compare( const CURRENCY4 *c1, const CURRENCY4 *c2 )
{
char sign1, sign2 ;
short int loop ;
long result ;
sign1 = (short int)(c1->lo[3]) >= 0 ? 1 : -1 ;
sign2 = (short int)(c2->lo[3]) >= 0 ? 1 : -1 ;
if ( sign1 != sign2 ) /* one positive, one negative, so comparison easy */
{
if ( sign1 == -1 )
return -1 ;
else
return 1 ;
}
if ( sign1 == -1 ) /* negative comparison, larger value is smaller */
{
for ( loop = 3 ; loop > 0 ; loop-- )
{
result = c1->lo[loop] ;
result -= c2->lo[loop] ;
if ( result < 0 )
return 1 ;
if ( result > 0 )
return -1 ;
}
return 0 ;
}
/* otherwise both values positive, larger is larger */
for ( loop = 3 ; loop > 0 ; loop-- )
{
result = c1->lo[loop] ;
result -= c2->lo[loop] ;
if ( result < 0 )
return -1 ;
if ( result > 0 )
return 1 ;
}
return 0 ;
}
int S4FUNCTION currency4add( CURRENCY4 *result, const CURRENCY4 *c1, const CURRENCY4 *c2 )
{
char sign1, sign2, carry ;
short int loop ;
long val1, val2, resultVal ;
sign1 = (short int)(c1->lo[3]) >= 0 ? 1 : -1 ;
sign2 = (short int)(c2->lo[3]) >= 0 ? 1 : -1 ;
carry = 0 ;
for ( loop = 0 ; loop < 4 ; loop++ )
{
if ( sign1 == -1 && sign2 == -1 )
{
val1 = -(short int)(c1->lo[loop]) ;
val2 = -(short int)(c2->lo[loop]) ;
if ( val1 == 0 )
val1 = 65536 ;
if ( val2 == 0 )
val2 = 65536 ;
if ( loop != 0 )
val2-- ;
}
else
{
val1 = c1->lo[loop] ;
val2 = c2->lo[loop] ;
}
resultVal = val1 + val2 + carry ;
carry = 0 ;
if ( resultVal > USHRT_MAX )
{
#ifdef S4TESTING
if ( ( resultVal - (long)USHRT_MAX ) > USHRT_MAX )
return error4( 0, e4info, E99999 ) ;
#endif
carry = 1 ;
result->lo[loop] = (int)(resultVal - (long)USHRT_MAX - 1) ;
}
else
result->lo[loop] = (int)resultVal ;
if ( sign1 == -1 && sign2 == -1 )
result->lo[loop] = -((short int)result->lo[loop]) ;
}
return 0 ;
}
int S4FUNCTION currency4subtract( CURRENCY4 *result, const CURRENCY4 *c1, const CURRENCY4 *c2 )
{
CURRENCY4 temp ;
memcpy( &temp, c2, sizeof( CURRENCY4 ) ) ;
negate( &temp, &temp ) ;
currency4add( result, c1, &temp ) ;
return 0 ;
}
int S4FUNCTION currency4multiplyShort( CURRENCY4 *result, const CURRENCY4 *c1, const short c2 )
{
int loop, sign1, sign2, signResult, pos ;
CURRENCY4 cur1, hold ;
unsigned long val1, valResult ;
short int cur2 ;
sign1 = (short int)(c1->lo[3]) >= 0 ? 1 : -1 ;
sign2 = c2 >= 0 ? 1 : -1 ;
if ( sign1 == -1 )
{
negate( &cur1, c1 ) ;
signResult = -1 ;
}
else
{
memcpy( &cur1, c1, sizeof( CURRENCY4 ) ) ;
signResult = 1 ;
}
if ( sign2 == -1 )
{
cur2 = -c2 ;
signResult *= -1 ;
}
else /* no change to sign */
cur2 = c2 ;
memset( result, 0, sizeof( CURRENCY4 ) ) ;
for ( loop = 0 ; loop < 4 ; loop++ )
{
val1 = cur1.lo[loop] ;
pos = loop ;
if ( pos >= 4 ) /* too large to store results */
break ;
if ( val1 == 0 )
continue ;
valResult = val1 * cur2 ;
memset( &hold, 0, sizeof( CURRENCY4 ) ) ;
if ( pos == 3 ) /* only least significant bytes important */
memcpy( &(hold.lo[pos]), &valResult, 2 ) ;
else
memcpy( &(hold.lo[pos]), &valResult, 4 ) ;
currency4add( result, result, &hold ) ;
}
if ( signResult == -1 )
negate( result, result ) ;
return 0 ;
}
#ifdef NOT_IMPLEMENTED_YET
int currency4multiply( CURRENCY4 *result, const CURRENCY4 *c1, const CURRENCY4 *c2 )
{
int loop, sign1, sign2, signResult, jLoop, pos ;
CURRENCY4 cur1, cur2, hold, tenThousand ;
unsigned long val1, val2, valResult ;
sign1 = (short int)(c1->lo[3]) >= 0 ? 1 : -1 ;
sign2 = (short int)(c2->lo[3]) >= 0 ? 1 : -1 ;
if ( sign1 == -1 )
{
negate( &cur1, c1 ) ;
signResult = -1 ;
}
else
{
memcpy( &cur1, c1, sizeof( CURRENCY4 ) ) ;
signResult = 1 ;
}
if ( sign2 == -1 )
{
negate( &cur2, c2 ) ;
signResult *= -1 ;
}
else /* no change to sign */
memcpy( &cur2, c2, sizeof( CURRENCY4 ) ) ;
memset( result, 0, sizeof( CURRENCY4 ) ) ;
memset( &tenThousand, 0, sizeof( CURRENCY4 ) ) ;
tenThousand.lo[0] = 0x2710 ;
for ( jLoop = 0 ; jLoop < 4 ; jLoop++ )
{
val2 = cur2.lo[jLoop] ;
if ( val2 == 0 )
continue ;
for ( loop = 0 ; loop < 4 ; loop++ )
{
val1 = cur1.lo[loop] ;
pos = loop + jLoop ;
if ( pos >= 4 ) /* too large to store results */
break ;
if ( val1 == 0 )
continue ;
valResult = val1 * val2 ;
memset( &hold, 0, sizeof( CURRENCY4 ) ) ;
if ( pos == 3 ) /* only least significant bytes important */
memcpy( &(hold.lo[pos]), &valResult, 2 ) ;
else
memcpy( &(hold.lo[pos]), &valResult, 4 ) ;
currency4add( result, result, &hold ) ;
}
}
if ( signResult == -1 )
negate( result, result ) ;
return 0 ;
}
#endif
static void negate( CURRENCY4 *result, const CURRENCY4 *source )
{
int loop ;
CURRENCY4 one ;
if ( ( (short int)(source->lo[3]) >= 0 ? 1 : -1 ) == -1 ) /* negative */
{
memset( &one, 0, sizeof( CURRENCY4 ) ) ;
one.lo[0] = 0x0001 ;
for ( loop = 0; loop < 4 ; loop++ )
result->lo[loop] = ~source->lo[loop] ;
currency4add( result, result, &one ) ;
}
else /* positive */
{
memset( &one, (unsigned char)0xFF, sizeof( CURRENCY4 ) ) ;
memcpy( result, source, sizeof( CURRENCY4 ) ) ;
currency4add( result, result, &one ) ;
for ( loop = 0; loop < 4 ; loop++ )
result->lo[loop] = ~result->lo[loop] ;
}
}
static void shiftLeft( long *left, long *right, int numShift )
{
int loop ;
for ( loop = 0 ; loop < numShift ; loop++ )
{
*left = *left << 1 ;
*left = *left | ( 1 * ( *right & 0x80000000 ) ) ;
*right = *right << 1 ;
}
}
static void shiftRight( long *left, long *right, int numShift )
{
int loop ;
for ( loop = 0 ; loop < numShift ; loop++ )
{
*right = *right >> 1 ;
*right = *right | ( 0x80000000 * ( *left & 0x00000001 ) ) ;
*left = *left >> 1 ;
}
}
int S4FUNCTION currency4divideShort( CURRENCY4 *result, const CURRENCY4 *c1, const short c2 )
{
unsigned short int shortResult ;
short int cur2 ;
unsigned long shortMod ;
int sign1, sign2, signResult, loop ;
CURRENCY4 add, cur1 ;
sign1 = (short int)(c1->lo[3]) >= 0 ? 1 : -1 ;
sign2 = c2 >= 0 ? 1 : -1 ;
if ( sign1 == -1 )
{
negate( &cur1, c1 ) ;
signResult = -1 ;
}
else
{
memcpy( &cur1, c1, sizeof( CURRENCY4 ) ) ;
signResult = 1 ;
}
if ( sign2 == -1 )
{
cur2 = -c2 ;
signResult *= -1 ;
}
else /* no change to sign */
cur2 = c2 ;
if ( cur2 == 0 )
return -1 ;
memset( result, 0, sizeof( CURRENCY4 ) ) ;
if ( *((long *)(&cur1.lo[2])) == 0 ) /* value smaller than max long */
{
*((long *)(&result->lo[0])) = *((long *)(&cur1.lo[0])) / cur2 ;
if ( signResult == -1 )
negate( result, result ) ;
return 0 ;
}
shortMod = 0 ;
for ( loop = 3 ; loop >= 0 ; loop-- )
{
memset( &add, 0, sizeof( CURRENCY4 ) ) ;
shortResult = (unsigned short)(((unsigned long)cur1.lo[loop] + shortMod )/ cur2) ;
memcpy( ((unsigned short int *)(&add)) + loop, &shortResult, sizeof( short int ) ) ;
if ( loop != 0 )
shortMod = ((unsigned long)(USHRT_MAX)+1) * ((cur1.lo[loop] + shortMod) % cur2 ) ;
currency4add( result, result, &add) ;
}
if ( signResult == -1 )
negate( result, result ) ;
return 0 ;
}
#ifdef NOT_IMPLEMENTED_YET
int currency4divide( CURRENCY4 *result, const CURRENCY4 *c1, const CURRENCY4 *c2 )
{
long topLeft, topRight, bottomLeft, bottomRight, resultRight ;
long stopShiftVal, holdLeft, holdRight ;
int sign1, sign2, signResult, numShift, signHold ;
CURRENCY4 add, subtract, hold, hold2, cur1, cur2 ;
sign1 = (short int)(c1->lo[3]) >= 0 ? 1 : -1 ;
sign2 = (short int)(c2->lo[3]) >= 0 ? 1 : -1 ;
if ( sign1 == -1 )
{
negate( &cur1, c1 ) ;
signResult = -1 ;
}
else
{
memcpy( &cur1, c1, sizeof( CURRENCY4 ) ) ;
signResult = 1 ;
}
if ( sign2 == -1 )
{
negate( &cur2, c2 ) ;
signResult *= -1 ;
}
else /* no change to sign */
memcpy( &cur2, c2, sizeof( CURRENCY4 ) ) ;
topLeft = *((long *)(&cur1.lo[2])) ;
topRight = *((long *)(&cur1.lo[0])) ;
bottomLeft = *((long *)(&cur2.lo[2])) ;
bottomRight = *((long *)(&cur2.lo[0])) ;
if ( bottomLeft == 0 && bottomRight == 0 ) /* divide by zero */
return -1 ;
memset( result, 0, sizeof( CURRENCY4 ) ) ;
if ( topLeft == 0 ) /* value smaller than max long */
{
if ( bottomLeft != 0 ) /* bottom larger than top */
return 0 ;
if ( bottomRight == 0 )
return -1 ;
resultRight = topRight / bottomRight ;
memcpy( &(result->lo[0]), &resultRight, sizeof( long ) ) ;
if ( signResult == -1 )
negate( result, result ) ;
return 0 ;
}
if ( topLeft < bottomLeft ) /* zero return */
{
if ( signResult == -1 )
negate( result, result ) ;
return 0 ;
}
if ( topLeft == bottomLeft ) /* either one or zero return */
{
if ( topRight >= bottomRight )
{
result->lo[0] = 1 ;
if ( signResult == -1 )
negate( result, result ) ;
}
return 0 ;
}
/* case where topLeft > 0 && topLeft > bottomLeft */
memcpy( &(hold.lo[0]), &topRight, sizeof( long ) ) ;
memcpy( &(hold.lo[2]), &topLeft, sizeof( long ) ) ;
stopShiftVal = topLeft / 2 ;
for ( ;; )
{
numShift = -1 ;
while( bottomLeft < stopShiftVal )
{
holdLeft = bottomLeft ;
holdRight = bottomRight ;
shiftLeft( &bottomLeft, &bottomRight, 1 ) ;
numShift++ ;
}
bottomLeft = holdLeft ;
bottomRight = holdRight ;
memset( &add, 0, sizeof( CURRENCY4 ) ) ;
currency4add( result, result, &add ) ;
#ifdef E4DEBUG
if ( ( (short int)(hold->lo[3]) >= 0 ? 1 : -1 ) == -1 )
return error4( 0, e4info, E90542 ) ;
#endif
for ( signHold = 1 ;; )
{
memcpy( &(subtract.lo[0]), &holdRight, sizeof( long ) ) ;
memcpy( &(subtract.lo[2]), &holdLeft, sizeof( long ) ) ;
memcpy( &hold2, &hold, sizeof( CURRENCY4 ) ) ;
currency4subtract( &hold, &hold, &subtract ) ;
signHold = (short int)(hold.lo[3]) >= 0 ? 1 : -1 ;
if ( signHold == -1 )
break ;
}
memcpy( &hold, &hold2, sizeof( CURRENCY4 ) ) ;
topLeft = *((long *)(&hold.lo[2])) ;
topRight = *((long *)(&hold.lo[0])) ;
stopShiftVal = topLeft / 2 ;
while ( bottomLeft > topLeft )
{
shiftRight( &bottomLeft, &bottomRight, 1 ) ;
numShift-- ;
}
}
if ( signResult == -1 )
negate( result, result ) ;
return 0 ;
}
#endif
/*
int currency4mod( CURRENCY4 *result, const CURRENCY4 *c1, const CURRENCY4 *c1 )
{
}
*/
int S4FUNCTION c4currencyToA( char *out, int outLen, const CURRENCY4 *sourceIn, int numDec )
{
int sign, pos, loop, reqdLen ;
CURRENCY4 hold, old, mod, sv, source ;
unsigned char buf[21] ;
unsigned long l1 ;
memcpy( &source, sourceIn, sizeof( CURRENCY4 ) ) ;
sign = (short int)(source.lo[3]) >= 0 ? 1 : -1 ;
if ( sign == -1 )
negate( &source, &source ) ;
memcpy( &hold, &source, sizeof( CURRENCY4 ) ) ;
memset( buf, 0, sizeof( buf ) ) ;
for ( pos = 0 ; pos < 20 ; pos++ )
{
if ( *((long *)(&hold.lo[2])) == 0L ) /* only right portion */
break ;
memcpy( &old, &hold, sizeof( CURRENCY4 ) ) ;
currency4divideShort( &hold, &hold, 10 ) ;
currency4multiplyShort( &sv, &hold, 10 ) ;
currency4subtract( &mod, &old, &sv ) ;
buf[pos] = (char)mod.lo[0] ;
}
/* if any portion is left, it is only the right portion */
if ( *((long *)(&hold.lo[2])) == 0L ) /* only right portion */
{
l1 = *((long *)(&hold.lo[0])) ;
if ( l1 == 0 )
{
if ( pos == 0 ) /* zero */
pos = -1 ;
}
else
{
for ( ; pos < 20 ; )
{
buf[pos] = (unsigned char) (l1 % 10) ;
l1 = l1 / 10 ;
if ( l1 == 0 )
break ;
pos++ ;
}
}
}
memset( out, 0, outLen ) ;
if ( pos == -1 )
{
reqdLen = 6 ; /* x.xxxx */
memset( out, '0', 5 ) ;
}
else
{
reqdLen = pos + 2 ; /* for decimal point and because pos is 1 less than amount */
if ( reqdLen < 6 )
{
memset( out, '0', 5 ) ;
reqdLen = 6 ; /* x.xxxx */
}
}
if ( (reqdLen+1) > outLen + (sign == -1) ) /* insufficient space */
return -1 ;
loop = 5 - (pos+1) ;
if ( loop < 0 )
loop = 0 ;
for ( ; pos >= 0 ; pos--, loop++ ) /* reverse the string */
out[loop] = buf[pos] + '0' ;
/* now reposition for the decimal points */
c4memmove( &(out[reqdLen-4]), &(out[reqdLen-5]), 4 ) ;
out[reqdLen-5] = '.' ;
/* now remove any decimal points according to input */
if ( numDec == 0 )
{
reqdLen -= 5 ;
out[reqdLen] = 0 ;
}
else
{
if ( numDec > 4 || numDec < 0 )
numDec = 4 ;
out[reqdLen-4+numDec] = 0 ;
reqdLen -= (4 - numDec) ;
}
if ( sign == -1 )
{
c4memmove( out+1, out, reqdLen + 1 ) ;
out[0] = '-' ;
}
return 0 ;
}
/* returns -1 if an invalid currency input string */
int S4FUNCTION c4atoCurrency( CURRENCY4 *result, const char *str, int strLen )
{
char buf[21] ;
int loop, len, numDecimals, numWhole, sign, numDigits ;
short int multiplier, mPower ;
long val ;
const char *decPt ;
CURRENCY4 temp, mult ;
char *ptr ;
memset( result, 0, sizeof( CURRENCY4 ) ) ;
decPt = 0 ;
len = strLen ;
if ( len == 0 )
return 0 ;
for ( ;; )
{
if ( str[0] != ' ' )
break ;
len-- ;
str++ ;
if ( len == 0 )
return 0 ;
}
if ( str[0] == '-' )
{
sign = -1 ;
str++ ;
len-- ;
}
else
{
sign = 1 ;
if ( str[0] == '+' )
{
str++ ;
len-- ;
}
}
while ( str[0] == '0' && str[1] == '0' ) /* get rid of leading zeros */
{
str++ ;
len-- ;
}
numDecimals = 0 ;
numWhole = len ;
for ( loop = len - 1 ; loop >= 0 ; loop-- )
{
if ( str[loop] == '.' )
{
numDecimals = len - loop - 1 ;
numWhole = len - numDecimals - 1 ;
decPt = &str[loop]+1 ;
break ;
}
}
if ( numDecimals > 4 )
return -1 ;
numDigits = numWhole + 4 ;
if ( numDigits > 20 )
return -1 ;
memcpy( buf, str, numWhole ) ;
if ( decPt != 0 )
c4memmove( buf+numWhole, decPt, numDecimals ) ;
for ( loop = numDecimals ; loop < 4 ; loop++ )
{
buf[numWhole+loop] = '0' ;
}
buf[numDigits] = 0 ;
if ( numDigits < 10 || ( numDigits == 10 && ( str[0] <= '3' && str[0] >= '0' ) ) )
{
/* fits in a single long */
val = c4atol( buf, strlen( buf ) ) ;
if ( sign == -1 )
val = -val ;
if ( val == 0 ) /* negative 0 is still zero */
sign = 1 ;
if ( sign == 1 ) /* positive value */
{
result->lo[3] = 0 ;
result->lo[2] = 0 ;
}
else /* negative value */
{
result->lo[3] = 0xFFFF ;
result->lo[2] = 0xFFFF ;
}
memcpy( &result->lo[0], &val, sizeof( long ) ) ;
return 0 ;
}
/* more complex scenario because number is larger than a long */
/* first get the first 9 bytes and store to long */
val = c4atol( buf, 9 ) ;
memcpy( &result->lo[0], &val, sizeof( long ) ) ;
ptr = buf + 9 ;
numDigits -= 9 ;
while ( numDigits > 4 )
{
multiplier = c4atoi( ptr, 4 ) ;
memset( &mult, 0, sizeof( CURRENCY4 ) ) ;
mult.lo[0] = 10000 ;
currency4multiplyShort( &temp, result, 10000 ) ;
*result = temp ;
if ( multiplier != 0 ) /* add */
{
memset( &temp, 0, sizeof( temp ) ) ;
memcpy( &(temp.lo[0]), &multiplier, sizeof( short ) ) ;
currency4add( result, result, &temp ) ;
}
numDigits -= 4 ;
ptr += 4 ;
}
if ( numDigits != 0 )
{
multiplier = c4atoi( ptr, numDigits ) ;
mPower = 1 ;
for ( ; numDigits > 0 ; numDigits-- )
mPower *= 10 ;
currency4multiplyShort( &temp, result, mPower ) ;
*result = temp ;
if ( multiplier != 0 ) /* add */
{
memset( &temp, 0, sizeof( temp ) ) ;
memcpy( &(temp.lo[0]), &multiplier, sizeof( short ) ) ;
currency4add( result, result, &temp ) ;
}
}
if ( sign == -1 )
{
memset( &mult, 0, sizeof( CURRENCY4 ) ) ;
mult.lo[0] = 0x0001 ;
currency4subtract( result, result, &mult ) ;
for ( loop = 0; loop < 4 ; loop++ )
result->lo[loop] = ~result->lo[loop] ;
}
return 0 ;
}
#ifndef S4OFF_WRITE
void S4FUNCTION f4assignCurrency( FIELD4 *field, char *str )
{
#ifdef S4VBASIC
if ( c4parm_check( field, 3, E90541 ) )
return ;
#endif
#ifdef E4PARM_HIGH
if ( field == 0 || str == 0 )
{
error4( 0, e4parm_null, E90541 ) ;
return ;
}
#endif
if ( field->type != r4currency )
{
#ifdef E4PARM_HIGH
error4( field->data->codeBase, e4parm, E81409 ) ;
#endif
return ;
}
#ifdef E4ANALYZE
if ( field->data == 0 )
{
error4( 0, e4struct, E90541 ) ;
return ;
}
if ( field->data->codeBase == 0 )
{
error4( 0, e4struct, E90541 ) ;
return ;
}
#endif
#ifdef E4PARM_HIGH
if ( field->type != r4currency )
{
error4( field->data->codeBase, e4parm, E81404 ) ;
return ;
}
#endif
if ( error4code( field->data->codeBase ) < 0 )
return ;
#ifndef S4SERVER
#ifndef S4OFF_ENFORCE_LOCK
if ( field->data->codeBase->lockEnforce && field->data->recNum > 0L )
if ( d4lockTest( field->data, field->data->recNum ) != 1 )
{
error4( field->data->codeBase, e4lock, E90541 ) ;
return ;
}
#endif
#endif
c4atoCurrency( (CURRENCY4 *)f4assignPtr( field ), str, strlen( str ) ) ;
}
#endif /* S4OFF_WRITE */
/* this function uses the same memory as f4str() */
char *S4FUNCTION f4currency( const FIELD4 *field, int numDec )
{
CODE4 *codeBase ;
#ifdef S4VBASIC
if ( c4parm_check( field, 3, E90542 ) )
return -1 ;
#endif
#ifdef E4PARM_HIGH
if ( field == 0 || numDec < 0 || numDec > 4 )
{
error4( 0, e4parm, E90542 ) ;
return 0 ;
}
#endif
codeBase = field->data->codeBase ;
#ifdef E4PARM_HIGH
if ( field->type != r4currency )
{
error4( codeBase, e4parm, E81409 ) ;
return 0 ;
}
#endif
if ( error4code( codeBase ) < 0 )
return 0 ;
if ( codeBase->bufLen <= 20 ) /* not room for field length + null */
{
if ( u4allocAgain( codeBase, &codeBase->fieldBuffer, &codeBase->bufLen, 21 ) < 0 )
{
#ifdef E4STACK
error4stack( codeBase, e4memory, E90542 ) ;
#endif
return 0 ;
}
}
else
codeBase->fieldBuffer[20] = 0 ;
c4currencyToA( codeBase->fieldBuffer, 20, (CURRENCY4 *)f4ptr( field ), numDec ) ;
return codeBase->fieldBuffer ;
}
#ifndef S4OFF_WRITE
void S4FUNCTION f4assignNotNull( FIELD4 *field )
{
FIELD4 *nullFlags ;
unsigned short int byteNum, offset ;
char mask ;
char *fPtr ;
if ( d4version( field->data ) != 0x30 )
return ;
if ( field->null == 1 )
{
if ( f4null( field ) )
{
nullFlags = &(field->data->fields[d4numFields(field->data)]) ;
#ifdef E4MISC
if ( nullFlags->type != r4system )
{
error4( field->data->codeBase, e4data, E83805 ) ;
return ;
}
#endif
byteNum = field->nullBit / 8 ;
#ifdef E4MISC
if ( nullFlags->len < ( byteNum + 1 ) )
{
error4( field->data->codeBase, e4data, E83805 ) ;
return ;
}
#endif
offset = ( field->nullBit - (byteNum * 8) ) ;
mask = (unsigned int)0x01 << offset ;
mask = ~mask ;
fPtr = f4ptr( nullFlags ) ;
fPtr[byteNum] = fPtr[byteNum] & mask ;
}
}
}
void S4FUNCTION f4assignNull( FIELD4 *field )
{
FIELD4 *nullFlags ;
unsigned short int byteNum, offset ;
char mask ;
char *fPtr ;
#ifdef S4VBASIC
if ( c4parm_check( field, 3, E90539 ) )
return ;
#endif
#ifdef E4PARM_HIGH
if ( field == 0 )
{
error4( 0, e4parm_null, E90539 ) ;
return ;
}
#endif
if ( error4code( field->data->codeBase ) < 0 )
return ;
if ( d4version( field->data ) != 0x30 )
{
error4( field->data->codeBase, e4parm, E81409 ) ;
return ;
}
#ifndef S4SERVER
#ifndef S4OFF_ENFORCE_LOCK
if ( field->data->codeBase->lockEnforce && field->data->recNum > 0L )
if ( d4lockTest( field->data, field->data->recNum ) != 1 )
{
error4( field->data->codeBase, e4lock, E90539 ) ;
return ;
}
#endif
#endif
if ( field->null == 1 )
{
nullFlags = &(field->data->fields[d4numFields(field->data)]) ;
#ifdef E4MISC
if ( nullFlags->type != r4system )
{
error4( field->data->codeBase, e4data, E83805 ) ;
return ;
}
#endif
byteNum = field->nullBit / 8 ;
#ifdef E4MISC
if ( nullFlags->len < ( byteNum + 1 ) )
{
error4( field->data->codeBase, e4data, E83805 ) ;
return ;
}
#endif
offset = ( field->nullBit - (byteNum * 8 ) ) ;
mask = 0x01 << offset ;
fPtr = f4assignPtr( nullFlags ) ;
fPtr[byteNum] = fPtr[byteNum] | mask ;
}
#ifdef E4PARM_HIGH
else
error4( field->data->codeBase, e4parm, E81409 ) ;
#endif
}
#endif /* S4OFF_WRITE */
int S4FUNCTION f4null( const FIELD4 *field )
{
FIELD4 *nullFlags ;
unsigned short int byteNum, offset ;
char mask ;
#ifdef S4VBASIC
if ( c4parm_check( field, 3, E90540 ) )
return -1 ;
#endif
#ifdef E4PARM_HIGH
if ( field == 0 )
return error4( 0, e4parm_null, E90540 ) ;
#endif
if ( d4version( field->data ) != 0x30 )
return 0 ;
if ( field->null == 1 )
{
nullFlags = &(field->data->fields[d4numFields(field->data)]) ;
#ifdef E4MISC
if ( nullFlags->type != r4system )
return error4( field->data->codeBase, e4data, E83805 ) ;
#endif
byteNum = field->nullBit / 8 ;
#ifdef E4MISC
if ( nullFlags->len < ( byteNum + 1 ) )
return error4( field->data->codeBase, e4data, E83805 ) ;
#endif
offset = ( field->nullBit - (byteNum * 8 ) ) ;
mask = 0x01 << offset ;
if ( ( f4ptr( nullFlags )[byteNum] & mask ) != 0 )
return 1 ;
}
return 0 ;
}
static void time4assign( char *ptr, unsigned long inVal )
{
long seconds, minutes, hours, milliSeconds, val ;
val = inVal / 1000 ; /* remove the thousandths's of seconds */
milliSeconds = inVal - ( val * 1000 ) ;
seconds = val % 60 ;
val /= 60 ;
minutes = val % 60 ;
val /= 60 ;
hours = val ;
c4ltoa45( hours, ptr, -2 ) ; /* - means fill with 0s */
ptr[2] = ':' ;
c4ltoa45( minutes, ptr+3, -2 ) ; /* - means fill with 0s */
ptr[5] = ':' ;
c4ltoa45( seconds, ptr+6, -2 ) ; /* - means fill with 0s */
if ( milliSeconds != 0 )
{
ptr[8] = ':' ;
c4ltoa45( milliSeconds, ptr+9, -3 ) ; /* - means fill with 0s */
}
}
/* this function uses the same memory as f4str() */
char S4PTR *S4FUNCTION f4dateTime( const FIELD4 *field )
{
CODE4 *codeBase ;
long val ;
char *fPtr ;
#ifdef S4VBASIC
if ( c4parm_check( field, 3, E90543 ) )
return -1 ;
#endif
#ifdef E4PARM_HIGH
if ( field == 0 )
{
error4( 0, e4parm, E90543 ) ;
return 0 ;
}
#endif
codeBase = field->data->codeBase ;
#ifdef E4PARM_HIGH
if ( field->type != r4dateTime )
{
error4( codeBase, e4parm, E81409 ) ;
return 0 ;
}
#endif
if ( error4code( codeBase ) < 0 )
return 0 ;
if ( codeBase->bufLen <= 20 ) /* not room for field length + null (incl. millisecs) */
{
if ( u4allocAgain( codeBase, &codeBase->fieldBuffer, &codeBase->bufLen, 21 ) < 0 )
{
#ifdef E4STACK
error4stack( codeBase, e4memory, E90542 ) ;
#endif
return 0 ;
}
}
memset( codeBase->fieldBuffer, ' ', 20 ) ;
codeBase->fieldBuffer[20] = 0 ;
fPtr = f4ptr( field ) ;
val = *((long *)fPtr) ; /* date */
date4assign( codeBase->fieldBuffer, val ) ;
val = *(((long *)fPtr) + 1) ; /* time */
time4assign( codeBase->fieldBuffer + 8, val ) ;
c4trimN( codeBase->fieldBuffer, 21 ) ;
return codeBase->fieldBuffer ;
}
/* input date time of format: "YYYYMMDDHH:MM:SS:MMM" */
#ifndef S4OFF_WRITE
void S4FUNCTION f4assignDateTime( FIELD4 *field, char *dateTime )
{
long date, time ;
if ( field->type != r4dateTime )
{
#ifdef E4PARM_HIGH
error4( field->data->codeBase, e4parm, E81409 ) ;
#endif
return ;
}
date = date4long( dateTime ) ;
time = time4long( dateTime + 8, strlen( dateTime ) - 8 ) ;
*((long *)f4assignPtr( field )) = date ;
*(((long *)f4assignPtr( field ))+1) = time ;
}
#endif /* S4OFF_WRITE */
#endif /* S4CLIENT_OR_FOX */
#ifdef S4VBASIC
int S4FUNCTION f4len_v( FIELD4 *f4 )
{
return (int)f4len( f4 );
}
#ifdef S4VB_DOS
char * f4name_v( FIELD4 *fld )
{
return v4str( f4name(fld) ) ;
}
#endif /* S4VB_DOS */
#endif /* S4VBASIC */
Reference in New Issue Copy Permalink