652 lines
15 KiB
C
652 lines
15 KiB
C
/*
|
|
* $Id$
|
|
|
|
Copyright(C) 1999 by Antonio Linares.
|
|
|
|
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 of the License, 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 program; if not, write to:
|
|
|
|
The Free Software Foundation, Inc.,
|
|
675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
You can contact me at: alinares@fivetech.com
|
|
*/
|
|
|
|
/* Harbour Project source code
|
|
http://www.Harbour-Project.org/
|
|
The following functions are Copyright 1999 Victor Szel <info@szelvesz.hu>:
|
|
hb_retnilen()
|
|
hb_retnllen()
|
|
hb_retndlen()
|
|
See doc/hdr_tpl.txt, Version 1.2 or later, for licensing terms.
|
|
*/
|
|
|
|
#include "extend.h"
|
|
#include "itemapi.h"
|
|
#include "set.h"
|
|
#include "dates.h"
|
|
|
|
/* NOTE: iParam = -1 can be used to access the return value. */
|
|
/* NOTE: iParam = 0 can be used to access the SELF object. */
|
|
|
|
PHB_ITEM hb_param( int iParam, WORD wMask )
|
|
{
|
|
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
|
|
{
|
|
PHB_ITEM pItem;
|
|
WORD wType;
|
|
|
|
if( iParam == -1 )
|
|
pItem = &stack.Return;
|
|
else
|
|
pItem = stack.pBase + 1 + iParam;
|
|
|
|
if( pItem->type & IT_BYREF )
|
|
pItem = hb_itemUnRef( pItem );
|
|
|
|
wType = pItem->type;
|
|
|
|
if( ( wType & wMask ) || ( wType == IT_NIL && wMask == IT_ANY ) )
|
|
return pItem;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* NOTE: Caller should not modify the buffer returned by this function */
|
|
|
|
char * hb_parc( int iParam, ... )
|
|
{
|
|
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
|
|
{
|
|
PHB_ITEM pItem;
|
|
|
|
if( iParam == -1 )
|
|
pItem = &stack.Return;
|
|
else
|
|
pItem = stack.pBase + 1 + iParam;
|
|
|
|
if( IS_BYREF( pItem ) )
|
|
pItem = hb_itemUnRef( pItem );
|
|
|
|
if( IS_STRING( pItem ) )
|
|
return pItem->item.asString.value;
|
|
|
|
else if( IS_ARRAY( pItem ) )
|
|
{
|
|
va_list va;
|
|
ULONG ulArrayIndex;
|
|
|
|
va_start( va, iParam );
|
|
ulArrayIndex = va_arg( va, ULONG );
|
|
va_end( va );
|
|
|
|
return hb_arrayGetCPtr( pItem, ulArrayIndex );
|
|
}
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
ULONG hb_parclen( int iParam, ... )
|
|
{
|
|
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
|
|
{
|
|
PHB_ITEM pItem;
|
|
|
|
if( iParam == -1 )
|
|
pItem = &stack.Return;
|
|
else
|
|
pItem = stack.pBase + 1 + iParam;
|
|
|
|
if( IS_BYREF( pItem ) )
|
|
pItem = hb_itemUnRef( pItem );
|
|
|
|
if( IS_STRING( pItem ) )
|
|
return pItem->item.asString.length;
|
|
|
|
else if( IS_ARRAY( pItem ) )
|
|
{
|
|
va_list va;
|
|
ULONG ulArrayIndex;
|
|
|
|
va_start( va, iParam );
|
|
ulArrayIndex = va_arg( va, ULONG );
|
|
va_end( va );
|
|
|
|
return hb_arrayGetCLen( pItem, ulArrayIndex );
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Same as _parclen() but returns the length including the */
|
|
/* terminating zero byte */
|
|
|
|
ULONG hb_parcsiz( int iParam, ... )
|
|
{
|
|
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
|
|
{
|
|
PHB_ITEM pItem;
|
|
|
|
if( iParam == -1 )
|
|
pItem = &stack.Return;
|
|
else
|
|
pItem = stack.pBase + 1 + iParam;
|
|
|
|
if( IS_BYREF( pItem ) )
|
|
pItem = hb_itemUnRef( pItem );
|
|
|
|
if( IS_STRING( pItem ) )
|
|
return pItem->item.asString.length + 1;
|
|
|
|
else if( IS_ARRAY( pItem ) )
|
|
{
|
|
va_list va;
|
|
ULONG ulArrayIndex;
|
|
|
|
va_start( va, iParam );
|
|
ulArrayIndex = va_arg( va, ULONG );
|
|
va_end( va );
|
|
|
|
return hb_arrayGetCLen( pItem, ulArrayIndex ) + 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
char * hb_pards( int iParam, ... )
|
|
{
|
|
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
|
|
{
|
|
PHB_ITEM pItem;
|
|
|
|
if( iParam == -1 )
|
|
pItem = &stack.Return;
|
|
else
|
|
pItem = stack.pBase + 1 + iParam;
|
|
|
|
if( IS_BYREF( pItem ) )
|
|
pItem = hb_itemUnRef( pItem );
|
|
|
|
if( IS_DATE( pItem ) )
|
|
{
|
|
long lDay, lMonth, lYear;
|
|
|
|
hb_dateDecode( pItem->item.asDate.value, &lDay, &lMonth, &lYear );
|
|
hb_dateStrPut( stack.szDate, lDay, lMonth, lYear );
|
|
stack.szDate[ 8 ] = '\0';
|
|
|
|
return stack.szDate; /* this guaranties good behavior when multithreading */
|
|
}
|
|
else if( IS_ARRAY( pItem ) )
|
|
{
|
|
va_list va;
|
|
ULONG ulArrayIndex;
|
|
|
|
va_start( va, iParam );
|
|
ulArrayIndex = va_arg( va, ULONG );
|
|
va_end( va );
|
|
|
|
hb_arrayGetDS( pItem, ulArrayIndex, stack.szDate );
|
|
|
|
return stack.szDate; /* this guaranties good behavior when multithreading */
|
|
}
|
|
}
|
|
|
|
return " "; /* 8 spaces */
|
|
}
|
|
|
|
int hb_parl( int iParam, ... )
|
|
{
|
|
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
|
|
{
|
|
PHB_ITEM pItem;
|
|
|
|
if( iParam == -1 )
|
|
pItem = &stack.Return;
|
|
else
|
|
pItem = stack.pBase + 1 + iParam;
|
|
|
|
if( IS_BYREF( pItem ) )
|
|
pItem = hb_itemUnRef( pItem );
|
|
|
|
if( IS_LOGICAL( pItem ) )
|
|
return pItem->item.asLogical.value ? 1 : 0;
|
|
|
|
else if( IS_INTEGER( pItem ) )
|
|
return pItem->item.asInteger.value != 0 ? 1 : 0;
|
|
|
|
else if( IS_LONG( pItem ) )
|
|
return pItem->item.asLong.value != 0 ? 1 : 0;
|
|
|
|
else if( IS_DOUBLE( pItem ) )
|
|
return pItem->item.asDouble.value != 0.0 ? 1 : 0;
|
|
|
|
else if( IS_ARRAY( pItem ) )
|
|
{
|
|
va_list va;
|
|
ULONG ulArrayIndex;
|
|
|
|
va_start( va, iParam );
|
|
ulArrayIndex = va_arg( va, ULONG );
|
|
va_end( va );
|
|
|
|
return hb_arrayGetL( pItem, ulArrayIndex ) ? 1 : 0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
double hb_parnd( int iParam, ... )
|
|
{
|
|
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
|
|
{
|
|
PHB_ITEM pItem;
|
|
|
|
if( iParam == -1 )
|
|
pItem = &stack.Return;
|
|
else
|
|
pItem = stack.pBase + 1 + iParam;
|
|
|
|
if( IS_BYREF( pItem ) )
|
|
pItem = hb_itemUnRef( pItem );
|
|
|
|
if( IS_DOUBLE( pItem ) )
|
|
return pItem->item.asDouble.value;
|
|
|
|
else if( IS_INTEGER( pItem ) )
|
|
return ( double ) pItem->item.asInteger.value;
|
|
|
|
else if( IS_LONG( pItem ) )
|
|
return ( double ) pItem->item.asLong.value;
|
|
|
|
else if( IS_ARRAY( pItem ) )
|
|
{
|
|
va_list va;
|
|
ULONG ulArrayIndex;
|
|
|
|
va_start( va, iParam );
|
|
ulArrayIndex = va_arg( va, ULONG );
|
|
va_end( va );
|
|
|
|
return hb_arrayGetND( pItem, ulArrayIndex );
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int hb_parni( int iParam, ... )
|
|
{
|
|
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
|
|
{
|
|
PHB_ITEM pItem;
|
|
|
|
if( iParam == -1 )
|
|
pItem = &stack.Return;
|
|
else
|
|
pItem = stack.pBase + 1 + iParam;
|
|
|
|
if( IS_BYREF( pItem ) )
|
|
pItem = hb_itemUnRef( pItem );
|
|
|
|
if( IS_INTEGER( pItem ) )
|
|
return pItem->item.asInteger.value;
|
|
|
|
else if( IS_LONG( pItem ) )
|
|
return ( int ) pItem->item.asLong.value;
|
|
|
|
else if( IS_DOUBLE( pItem ) )
|
|
return ( int ) pItem->item.asDouble.value;
|
|
|
|
else if( IS_ARRAY( pItem ) )
|
|
{
|
|
va_list va;
|
|
ULONG ulArrayIndex;
|
|
|
|
va_start( va, iParam );
|
|
ulArrayIndex = va_arg( va, ULONG );
|
|
va_end( va );
|
|
|
|
return ( int ) hb_arrayGetNL( pItem, ulArrayIndex );
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
long hb_parnl( int iParam, ... )
|
|
{
|
|
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
|
|
{
|
|
PHB_ITEM pItem;
|
|
|
|
if( iParam == -1 )
|
|
pItem = &stack.Return;
|
|
else
|
|
pItem = stack.pBase + 1 + iParam;
|
|
|
|
if( IS_BYREF( pItem ) )
|
|
pItem = hb_itemUnRef( pItem );
|
|
|
|
if( IS_LONG( pItem ) )
|
|
return pItem->item.asLong.value;
|
|
|
|
else if( IS_INTEGER( pItem ) )
|
|
return ( long ) pItem->item.asInteger.value;
|
|
|
|
else if( IS_DOUBLE( pItem ) )
|
|
return ( long ) pItem->item.asDouble.value;
|
|
|
|
else if( IS_DATE( pItem ) )
|
|
return pItem->item.asDate.value;
|
|
|
|
else if( IS_ARRAY( pItem ) )
|
|
{
|
|
va_list va;
|
|
ULONG ulArrayIndex;
|
|
|
|
va_start( va, iParam );
|
|
ulArrayIndex = va_arg( va, ULONG );
|
|
va_end( va );
|
|
|
|
return hb_arrayGetNL( pItem, ulArrayIndex );
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
ULONG hb_parinfa( int iParamNum, ULONG uiArrayIndex )
|
|
{
|
|
PHB_ITEM pArray = hb_param( iParamNum, IT_ARRAY );
|
|
|
|
if( pArray )
|
|
{
|
|
if( uiArrayIndex == 0 )
|
|
return hb_arrayLen( pArray );
|
|
else
|
|
return ( long ) hb_arrayGetType( pArray, uiArrayIndex );
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
WORD hb_parinfo( int iParam )
|
|
{
|
|
if( iParam == 0 )
|
|
return stack.pBase->item.asSymbol.paramcnt;
|
|
else
|
|
{
|
|
if( ( iParam > 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
|
|
{
|
|
WORD wType;
|
|
|
|
if( iParam == -1 )
|
|
wType = stack.Return.type;
|
|
else
|
|
wType = ( stack.pBase + 1 + iParam )->type;
|
|
|
|
if( wType & IT_BYREF )
|
|
{
|
|
PHB_ITEM pItem;
|
|
|
|
if( iParam == -1 )
|
|
pItem = hb_itemUnRef( &stack.Return );
|
|
else
|
|
pItem = hb_itemUnRef( stack.pBase + 1 + iParam );
|
|
|
|
if( pItem )
|
|
wType |= pItem->type;
|
|
}
|
|
|
|
return wType;
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
WORD hb_pcount( void )
|
|
{
|
|
return stack.pBase->item.asSymbol.paramcnt;
|
|
}
|
|
|
|
void hb_ret( void )
|
|
{
|
|
hb_itemClear( &stack.Return );
|
|
}
|
|
|
|
void hb_reta( ULONG ulLen ) /* undocumented hb_reta() */
|
|
{
|
|
hb_arrayNew( &stack.Return, ulLen );
|
|
}
|
|
|
|
void hb_retc( char * szText )
|
|
{
|
|
hb_itemPutC( &stack.Return, szText );
|
|
}
|
|
|
|
void hb_retclen( char * szText, ULONG ulLen )
|
|
{
|
|
hb_itemPutCL( &stack.Return, szText, ulLen );
|
|
}
|
|
|
|
void hb_retds( char * szDate ) /* szDate must have yyyymmdd format */
|
|
{
|
|
hb_itemPutDS( &stack.Return, szDate );
|
|
}
|
|
|
|
void hb_retl( int iLogical )
|
|
{
|
|
hb_itemPutL( &stack.Return, iLogical ? TRUE : FALSE );
|
|
}
|
|
|
|
void hb_retnd( double dNumber )
|
|
{
|
|
hb_itemPutND( &stack.Return, dNumber );
|
|
}
|
|
|
|
void hb_retni( int iNumber )
|
|
{
|
|
hb_itemPutNI( &stack.Return, iNumber );
|
|
}
|
|
|
|
void hb_retnl( long lNumber )
|
|
{
|
|
hb_itemPutNL( &stack.Return, lNumber );
|
|
}
|
|
|
|
void hb_retndlen( double dNumber, WORD wWidth, WORD wDecimal )
|
|
{
|
|
hb_itemPutNDLen( &stack.Return, dNumber, wWidth, wDecimal );
|
|
}
|
|
|
|
void hb_retnilen( int iNumber, WORD wWidth )
|
|
{
|
|
hb_itemPutNILen( &stack.Return, iNumber, wWidth );
|
|
}
|
|
|
|
void hb_retnllen( long lNumber, WORD wWidth )
|
|
{
|
|
hb_itemPutNLLen( &stack.Return, lNumber, wWidth );
|
|
}
|
|
|
|
void hb_storc( char * szText, int iParam, ... )
|
|
{
|
|
if( iParam > 0 && iParam <= hb_pcount() )
|
|
{
|
|
PHB_ITEM pItem = stack.pBase + 1 + iParam;
|
|
|
|
if( IS_BYREF( pItem ) )
|
|
hb_itemPutC( hb_itemUnRef( pItem ), szText );
|
|
|
|
else if( IS_ARRAY( pItem ) )
|
|
{
|
|
va_list va;
|
|
PHB_ITEM pItemNew = hb_itemPutC( NULL, szText );
|
|
va_start( va, iParam );
|
|
hb_arraySet( pItem, va_arg( va, ULONG ), pItemNew );
|
|
va_end( va );
|
|
hb_itemRelease( pItemNew );
|
|
}
|
|
}
|
|
else if( iParam == -1 )
|
|
hb_itemPutC( &stack.Return, szText );
|
|
}
|
|
|
|
void hb_storclen( char * szText, ULONG ulLen, int iParam, ... )
|
|
{
|
|
if( iParam > 0 && iParam <= hb_pcount() )
|
|
{
|
|
PHB_ITEM pItem = stack.pBase + 1 + iParam;
|
|
|
|
if( IS_BYREF( pItem ) )
|
|
hb_itemPutCL( hb_itemUnRef( pItem ), szText, ulLen );
|
|
|
|
else if( IS_ARRAY( pItem ) )
|
|
{
|
|
va_list va;
|
|
PHB_ITEM pItemNew = hb_itemPutCL( NULL, szText, ulLen );
|
|
va_start( va, iParam );
|
|
hb_arraySet( pItem, va_arg( va, ULONG ), pItemNew );
|
|
va_end( va );
|
|
hb_itemRelease( pItemNew );
|
|
}
|
|
}
|
|
else if( iParam == -1 )
|
|
hb_itemPutCL( &stack.Return, szText, ulLen );
|
|
}
|
|
|
|
/* szDate should have yyyymmdd format */
|
|
|
|
void hb_stords( char * szDate, int iParam, ... )
|
|
{
|
|
if( iParam > 0 && iParam <= hb_pcount() )
|
|
{
|
|
PHB_ITEM pItem = stack.pBase + 1 + iParam;
|
|
|
|
if( IS_BYREF( pItem ) )
|
|
hb_itemPutDS( hb_itemUnRef( pItem ), szDate );
|
|
|
|
else if( IS_ARRAY( pItem ) )
|
|
{
|
|
va_list va;
|
|
PHB_ITEM pItemNew = hb_itemPutDS( NULL, szDate );
|
|
va_start( va, iParam );
|
|
hb_arraySet( pItem, va_arg( va, ULONG ), pItemNew );
|
|
va_end( va );
|
|
hb_itemRelease( pItemNew );
|
|
}
|
|
}
|
|
else if( iParam == -1 )
|
|
hb_itemPutDS( &stack.Return, szDate );
|
|
}
|
|
|
|
void hb_storl( int iLogical, int iParam, ... )
|
|
{
|
|
if( iParam > 0 && iParam <= hb_pcount() )
|
|
{
|
|
PHB_ITEM pItem = stack.pBase + 1 + iParam;
|
|
|
|
if( IS_BYREF( pItem ) )
|
|
hb_itemPutL( hb_itemUnRef( pItem ), iLogical ? TRUE : FALSE );
|
|
|
|
else if( IS_ARRAY( pItem ) )
|
|
{
|
|
va_list va;
|
|
PHB_ITEM pItemNew = hb_itemPutL( NULL, iLogical ? TRUE : FALSE );
|
|
va_start( va, iParam );
|
|
hb_arraySet( pItem, va_arg( va, ULONG ), pItemNew );
|
|
va_end( va );
|
|
hb_itemRelease( pItemNew );
|
|
}
|
|
}
|
|
else if( iParam == -1 )
|
|
hb_itemPutL( &stack.Return, iLogical ? TRUE : FALSE );
|
|
}
|
|
|
|
void hb_storni( int iValue, int iParam, ... )
|
|
{
|
|
if( iParam > 0 && iParam <= hb_pcount() )
|
|
{
|
|
PHB_ITEM pItem = stack.pBase + 1 + iParam;
|
|
|
|
if( IS_BYREF( pItem ) )
|
|
hb_itemPutNI( hb_itemUnRef( pItem ), iValue );
|
|
|
|
else if( IS_ARRAY( pItem ) )
|
|
{
|
|
va_list va;
|
|
PHB_ITEM pItemNew = hb_itemPutNI( NULL, iValue );
|
|
va_start( va, iParam );
|
|
hb_arraySet( pItem, va_arg( va, ULONG ), pItemNew );
|
|
va_end( va );
|
|
hb_itemRelease( pItemNew );
|
|
}
|
|
}
|
|
else if( iParam == -1 )
|
|
hb_itemPutNI( &stack.Return, iValue );
|
|
}
|
|
|
|
void hb_stornl( long lValue, int iParam, ... )
|
|
{
|
|
if( iParam > 0 && iParam <= hb_pcount() )
|
|
{
|
|
PHB_ITEM pItem = stack.pBase + 1 + iParam;
|
|
|
|
if( IS_BYREF( pItem ) )
|
|
hb_itemPutNI( hb_itemUnRef( pItem ), lValue );
|
|
|
|
else if( IS_ARRAY( pItem ) )
|
|
{
|
|
va_list va;
|
|
PHB_ITEM pItemNew = hb_itemPutNL( NULL, lValue );
|
|
va_start( va, iParam );
|
|
hb_arraySet( pItem, va_arg( va, ULONG ), pItemNew );
|
|
va_end( va );
|
|
hb_itemRelease( pItemNew );
|
|
}
|
|
}
|
|
else if( iParam == -1 )
|
|
hb_itemPutNL( &stack.Return, lValue );
|
|
}
|
|
|
|
void hb_stornd( double dNumber, int iParam, ... )
|
|
{
|
|
if( iParam > 0 && iParam <= hb_pcount() )
|
|
{
|
|
PHB_ITEM pItem = stack.pBase + 1 + iParam;
|
|
|
|
if( IS_BYREF( pItem ) )
|
|
hb_itemPutNI( hb_itemUnRef( pItem ), dNumber );
|
|
|
|
else if( IS_ARRAY( pItem ) )
|
|
{
|
|
va_list va;
|
|
PHB_ITEM pItemNew = hb_itemPutND( NULL, dNumber );
|
|
va_start( va, iParam );
|
|
hb_arraySet( pItem, va_arg( va, ULONG ), pItemNew );
|
|
va_end( va );
|
|
hb_itemRelease( pItemNew );
|
|
}
|
|
}
|
|
else if( iParam == -1 )
|
|
hb_itemPutND( &stack.Return, dNumber );
|
|
}
|
|
|