fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2010-07-07 15:40 UTC+0200 Viktor Szakats (harbour.01 syenar.hu)

Browse Source 
* src/vm/extend.c
  * include/hbapicdp.h
  * include/hbstack.h
  * include/hbgtcore.h
  * include/hbapifs.h
  * include/hbxvm.h
  * include/hbdefs.h
  * include/hbmacro.h
  * include/hbapi.h
  * include/hbapiitm.h
  * include/hbcomp.h
  * include/hbsxfunc.h
  * include/hbexprop.h
  * include/hbapigt.h
  * include/hbhash.h
  * include/hbregex.h
    * HB_SIZE/HB_ISIZ/some HB_MAXINT variables renamed.
This commit is contained in:
Viktor Szakats
2010-07-07 13:42:39 +00:00
parent ce80cf2c1e
commit 14122cb345
17 changed files with 253 additions and 233 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
harbour/ChangeLog
View File

@@ -16,6 +16,25 @@
The license applies to all entries newer than 2009-04-28.
*/
2010-07-07 15:40 UTC+0200 Viktor Szakats (harbour.01 syenar.hu)
* src/vm/extend.c
* include/hbapicdp.h
* include/hbstack.h
* include/hbgtcore.h
* include/hbapifs.h
* include/hbxvm.h
* include/hbdefs.h
* include/hbmacro.h
* include/hbapi.h
* include/hbapiitm.h
* include/hbcomp.h
* include/hbsxfunc.h
* include/hbexprop.h
* include/hbapigt.h
* include/hbhash.h
* include/hbregex.h
* HB_SIZE/HB_ISIZ/some HB_MAXINT variables renamed.
2010-07-07 14:50 UTC+0200 Przemyslaw Czerpak (druzus/at/priv.onet.pl)
* harbour/src/rtl/cdpapi.c
% removed one redundant if() condition
@@ -42,8 +61,9 @@
hbide where hbmk2 is. Plus I used hb_processRun(), pls
replace it with any method is fit for hbide.
- Deleted redundant copy-pasted (and outdated) code from
hbmk2 hbide source into hbide. (BTW their licence
was also incompatible, pls don't put it back there)
hbmk2 source into hbide. (BTW their licences
were also incompatible, pls don't put this code back
there)
* utils/hbmk2/hbmk2.prg
+ Added comments to converted .hbp files about the original

240
harbour/include/hbapi.h
View File

@@ -486,10 +486,10 @@ extern HB_SYMB hb_symEval;
extern HB_EXPORT void hb_xinit( void ); /* Initialize fixed memory subsystem */
extern HB_EXPORT void hb_xexit( void ); /* Deinitialize fixed memory subsystem */
extern HB_EXPORT void * hb_xalloc( HB_SIZE ulSize ); /* allocates memory, returns NULL on failure */
extern HB_EXPORT void * hb_xgrab( HB_SIZE ulSize ) HB_MALLOC_ATTR HB_ALLOC_SIZE_ATTR( 1 ); /* allocates memory, exits on failure */
extern HB_EXPORT void * hb_xalloc( HB_SIZE nSize ); /* allocates memory, returns NULL on failure */
extern HB_EXPORT void * hb_xgrab( HB_SIZE nSize ) HB_MALLOC_ATTR HB_ALLOC_SIZE_ATTR( 1 ); /* allocates memory, exits on failure */
extern HB_EXPORT void hb_xfree( void * pMem ); /* frees memory */
extern HB_EXPORT void * hb_xrealloc( void * pMem, HB_SIZE ulSize ) HB_ALLOC_SIZE_ATTR( 2 ); /* reallocates memory */
extern HB_EXPORT void * hb_xrealloc( void * pMem, HB_SIZE nSize ) HB_ALLOC_SIZE_ATTR( 2 ); /* reallocates memory */
extern HB_EXPORT HB_SIZE hb_xsize( void * pMem ); /* returns the size of an allocated memory block */
extern HB_EXPORT HB_SIZE hb_xquery( int iMode ); /* Query different types of memory information */
extern HB_EXPORT HB_BOOL hb_xtraced( void );
@@ -506,7 +506,7 @@ extern void hb_xRefInc( void * pMem ); /* increment reference counter *
extern HB_BOOL hb_xRefDec( void * pMem ); /* decrement reference counter, return HB_TRUE when 0 reached */
extern void hb_xRefFree( void * pMem ); /* decrement reference counter and free the block when 0 reached */
extern HB_COUNTER hb_xRefCount( void * pMem ); /* return number of references */
extern void * hb_xRefResize( void * pMem, HB_SIZE ulSave, HB_SIZE ulSize, HB_SIZE * pulAllocated ); /* reallocates memory, create copy if reference counter greater then 1 */
extern void * hb_xRefResize( void * pMem, HB_SIZE nSave, HB_SIZE nSize, HB_SIZE * pnAllocated ); /* reallocates memory, create copy if reference counter greater then 1 */
#if 0
@@ -543,8 +543,8 @@ extern void * hb_xRefResize( void * pMem, HB_SIZE ulSave, HB_SIZE ulSize, HB
#else
/* NOTE: otherwise, the hb_xmemcpy and hb_xmemset functions
will be used to copy and/or set HB_SIZE data blocks */
extern HB_EXPORT void * hb_xmemcpy( void * pDestArg, void * pSourceArg, HB_SIZE ulLen ); /* copy more than memcpy() can */
extern HB_EXPORT void * hb_xmemset( void * pDestArg, int iFill, HB_SIZE ulLen ); /* set more than memset() can */
extern HB_EXPORT void * hb_xmemcpy( void * pDestArg, void * pSourceArg, HB_SIZE nLen ); /* copy more than memcpy() can */
extern HB_EXPORT void * hb_xmemset( void * pDestArg, int iFill, HB_SIZE nLen ); /* set more than memset() can */
#endif
/* virtual memory */
@@ -579,7 +579,7 @@ typedef struct
}
HB_GC_FUNCS;
extern HB_EXPORT void * hb_gcAllocate( HB_SIZE ulSize, const HB_GC_FUNCS * pFuncs ); /* allocates a memory controlled by the garbage collector */
extern HB_EXPORT void * hb_gcAllocate( HB_SIZE nSize, const HB_GC_FUNCS * pFuncs ); /* allocates a memory controlled by the garbage collector */
extern HB_EXPORT void hb_gcFree( void * pAlloc ); /* deallocates a memory allocated by the garbage collector */
extern HB_EXPORT void * hb_gcLock( void * pAlloc ); /* do not release passed memory block */
extern HB_EXPORT void * hb_gcUnlock( void * pAlloc ); /* passed block is allowed to be released */
@@ -595,7 +595,7 @@ extern void hb_gcGripDrop( HB_ITEM_PTR pItem );
#ifdef _HB_API_INTERNAL_
extern const HB_GC_FUNCS * hb_gcFuncs( void *pBlock ); /* return cleanup function pointer */
extern void hb_gcAttach( void * pBlock );
extern void * hb_gcAllocRaw( HB_SIZE ulSize, const HB_GC_FUNCS * pFuncs ); /* allocates a memory controlled by the garbage collector */
extern void * hb_gcAllocRaw( HB_SIZE nSize, const HB_GC_FUNCS * pFuncs ); /* allocates a memory controlled by the garbage collector */
extern void hb_gcGripMark( void * Cargo ); /* mark complex variables inside given item as used */
extern void hb_gcItemRef( HB_ITEM_PTR pItem ); /* mark complex variables inside given item as used */
extern void hb_vmIsStackRef( void ); /* hvm.c - mark all local variables as used */
@@ -617,7 +617,7 @@ extern void hb_gcCollectAll( HB_BOOL fForce ); /* checks if all memory blo
/* Extend API */
extern HB_EXPORT HB_ULONG hb_parinfo( int iParam ); /* Determine the param count or data type */
extern HB_EXPORT HB_SIZE hb_parinfa( int iParamNum, HB_SIZE uiArrayIndex ); /* retrieve length or element type of an array parameter */
extern HB_EXPORT HB_SIZE hb_parinfa( int iParamNum, HB_SIZE nArrayIndex ); /* retrieve length or element type of an array parameter */
extern HB_EXPORT PHB_ITEM hb_param( int iParam, long lMask ); /* retrieve a generic parameter */
extern HB_EXPORT PHB_ITEM hb_paramError( int iParam ); /* Returns either the generic parameter or a NIL item if param not provided */
extern HB_EXPORT HB_BOOL hb_extIsArray( int iParam );
@@ -676,9 +676,9 @@ extern HB_EXPORT void hb_retc( const char * szText ); /* returns a string */
extern HB_EXPORT void hb_retc_null( void ); /* returns an empty string */
extern HB_EXPORT void hb_retc_buffer( char * szText ); /* sames as above, but accepts an allocated buffer */
extern HB_EXPORT void hb_retc_const( const char * szText ); /* returns a string as a pcode based string */
extern HB_EXPORT void hb_retclen( const char * szText, HB_SIZE ulLen ); /* returns a string with a specific length */
extern HB_EXPORT void hb_retclen_buffer( char * szText, HB_SIZE ulLen ); /* sames as above, but accepts an allocated buffer */
extern HB_EXPORT void hb_retclen_const( const char * szText, HB_SIZE ulLen ); /* returns a string with a specific length formed from a constant buffer */
extern HB_EXPORT void hb_retclen( const char * szText, HB_SIZE nLen ); /* returns a string with a specific length */
extern HB_EXPORT void hb_retclen_buffer( char * szText, HB_SIZE nLen ); /* sames as above, but accepts an allocated buffer */
extern HB_EXPORT void hb_retclen_const( const char * szText, HB_SIZE nLen ); /* returns a string with a specific length formed from a constant buffer */
extern HB_EXPORT void hb_retds( const char * szDate ); /* returns a date, must use YYYYMMDD format */
extern HB_EXPORT void hb_retd( int iYear, int iMonth, int iDay ); /* returns a date */
extern HB_EXPORT void hb_retdl( long lJulian ); /* returns a long value as a julian date */
@@ -695,7 +695,7 @@ extern HB_EXPORT void hb_retndlen( double dNumber, int iWidth, int iDec ); /*
extern HB_EXPORT void hb_retnilen( int iNumber, int iWidth ); /* returns a integer number, with specific width */
extern HB_EXPORT void hb_retnllen( long lNumber, int iWidth ); /* returns a long number, with specific width */
extern HB_EXPORT void hb_retnintlen( HB_MAXINT lNumber, int iWidth ); /* returns a long long number, with specific width */
extern HB_EXPORT void hb_reta( HB_SIZE ulLen ); /* returns an array with a specific length */
extern HB_EXPORT void hb_reta( HB_SIZE nLen ); /* returns an array with a specific length */
extern HB_EXPORT void hb_retptr( void * ptr ); /* returns a pointer */
extern HB_EXPORT void hb_retptrGC( void * ptr ); /* returns a pointer to an allocated memory, collected by GC */
#ifndef HB_LONG_LONG_OFF
@@ -710,14 +710,14 @@ extern HB_EXPORT void hb_retnlllen( HB_LONGLONG lNumber, int iWidth ); /* retu
#define hb_pcount() ( ( int ) ( hb_stackBaseItem() )->item.asSymbol.paramcnt )
#define hb_ret() hb_itemClear( hb_stackReturnItem() )
#define hb_reta( ulLen ) hb_arrayNew( hb_stackReturnItem(), ulLen )
#define hb_reta( nLen ) hb_arrayNew( hb_stackReturnItem(), nLen )
#define hb_retc( szText ) hb_itemPutC( hb_stackReturnItem(), szText )
#define hb_retc_null() hb_itemPutC( hb_stackReturnItem(), NULL )
#define hb_retc_buffer( szText ) hb_itemPutCPtr( hb_stackReturnItem(), szText )
#define hb_retc_const( szText ) hb_itemPutCConst( hb_stackReturnItem(), szText )
#define hb_retclen( szText, ulLen ) hb_itemPutCL( hb_stackReturnItem(), szText, ulLen )
#define hb_retclen_buffer( szText, ulLen ) hb_itemPutCLPtr( hb_stackReturnItem(), szText, ulLen )
#define hb_retclen_const( szText, ulLen ) hb_itemPutCLConst( hb_stackReturnItem(), szText, ulLen )
#define hb_retclen( szText, nLen ) hb_itemPutCL( hb_stackReturnItem(), szText, nLen )
#define hb_retclen_buffer( szText, nLen ) hb_itemPutCLPtr( hb_stackReturnItem(), szText, nLen )
#define hb_retclen_const( szText, nLen ) hb_itemPutCLConst( hb_stackReturnItem(), szText, nLen )
#define hb_retds( szDate ) hb_itemPutDS( hb_stackReturnItem(), szDate )
#define hb_retd( iYear, iMonth, iDay ) hb_itemPutD( hb_stackReturnItem(), iYear, iMonth, iDay )
#define hb_retdl( lJulian ) hb_itemPutDL( hb_stackReturnItem(), lJulian )
@@ -744,8 +744,8 @@ extern HB_EXPORT void hb_retnlllen( HB_LONGLONG lNumber, int iWidth ); /* retu
extern HB_EXPORT int hb_stor( int iParam ); /* stores a NIL on a variable by reference */
extern HB_EXPORT int hb_storc( const char * szText, int iParam ); /* stores a szString on a variable by reference */
extern HB_EXPORT int hb_storclen( const char * szText, HB_SIZE ulLength, int iParam ); /* stores a fixed length string on a variable by reference */
extern HB_EXPORT int hb_storclen_buffer( char * szText, HB_SIZE ulLength, int iParam ); /* stores a fixed length string buffer on a variable by reference */
extern HB_EXPORT int hb_storclen( const char * szText, HB_SIZE nLength, int iParam ); /* stores a fixed length string on a variable by reference */
extern HB_EXPORT int hb_storclen_buffer( char * szText, HB_SIZE nLength, int iParam ); /* stores a fixed length string buffer on a variable by reference */
extern HB_EXPORT int hb_stords( const char * szDate, int iParam ); /* szDate must have YYYYMMDD format */
extern HB_EXPORT int hb_stordl( long lJulian, int iParam ); /* lJulian must be a date in Julian format */
extern HB_EXPORT int hb_stortd( double dTimeStamp, int iParam ); /* stores a double value as timestamp on a variable by reference */
@@ -755,16 +755,16 @@ extern HB_EXPORT int hb_storni( int iValue, int iParam ); /* stores an intege
extern HB_EXPORT int hb_stornl( long lValue, int iParam ); /* stores a long on a variable by reference */
extern HB_EXPORT int hb_storns( HB_ISIZ nValue, int iParam ); /* stores a HB_SIZE on a variable by reference */
extern HB_EXPORT int hb_stornd( double dValue, int iParam ); /* stores a double on a variable by reference */
extern HB_EXPORT int hb_stornint( HB_MAXINT lValue, int iParam ); /* stores a HB_MAXINT on a variable by reference */
extern HB_EXPORT int hb_stornint( HB_MAXINT nValue, int iParam ); /* stores a HB_MAXINT on a variable by reference */
extern HB_EXPORT int hb_storptr( void * pointer, int iParam ); /* stores a pointer on a variable by reference */
extern HB_EXPORT int hb_storptrGC( void * pointer, int iParam ); /* stores a pointer to GC block on a variable by reference */
#ifndef HB_LONG_LONG_OFF
extern HB_EXPORT int hb_stornll( HB_LONGLONG lValue, int iParam ); /* stores a long long on a variable by reference */
extern HB_EXPORT int hb_stornll( HB_LONGLONG llValue, int iParam ); /* stores a long long on a variable by reference */
#endif
extern HB_EXPORT int hb_storvc( const char * szText, int iParam, ... ); /* stores a szString on a variable by reference */
extern HB_EXPORT int hb_storvclen( const char * szText, HB_SIZE ulLength, int iParam, ... ); /* stores a fixed length string on a variable by reference */
extern HB_EXPORT int hb_storvclen_buffer( char * szText, HB_SIZE ulLength, int iParam, ... ); /* stores a fixed length string buffer on a variable by reference */
extern HB_EXPORT int hb_storvclen( const char * szText, HB_SIZE nLength, int iParam, ... ); /* stores a fixed length string on a variable by reference */
extern HB_EXPORT int hb_storvclen_buffer( char * szText, HB_SIZE nLength, int iParam, ... ); /* stores a fixed length string buffer on a variable by reference */
extern HB_EXPORT int hb_storvds( const char * szDate, int iParam, ... ); /* szDate must have YYYYMMDD format */
extern HB_EXPORT int hb_storvdl( long lJulian, int iParam, ... ); /* lJulian must be a date in Julian format */
extern HB_EXPORT int hb_storvtd( double dTimeStamp, int iParam, ... ); /* stores a double value as timestamp on a variable by reference */
@@ -772,83 +772,83 @@ extern HB_EXPORT int hb_storvtdt( long lJulian, long lMilliSec, int iParam, .
extern HB_EXPORT int hb_storvl( int iLogical, int iParam, ... ); /* stores a logical integer on a variable by reference */
extern HB_EXPORT int hb_storvni( int iValue, int iParam, ... ); /* stores an integer on a variable by reference */
extern HB_EXPORT int hb_storvnl( long lValue, int iParam, ... ); /* stores a long on a variable by reference */
extern HB_EXPORT int hb_storvns( HB_ISIZ lValue, int iParam, ... ); /* stores a HB_SIZE on a variable by reference */
extern HB_EXPORT int hb_storvns( HB_ISIZ nValue, int iParam, ... ); /* stores a HB_SIZE on a variable by reference */
extern HB_EXPORT int hb_storvnd( double dValue, int iParam, ... ); /* stores a double on a variable by reference */
extern HB_EXPORT int hb_storvnint( HB_MAXINT lValue, int iParam, ... ); /* stores a HB_MAXINT on a variable by reference */
extern HB_EXPORT int hb_storvnint( HB_MAXINT nValue, int iParam, ... ); /* stores a HB_MAXINT on a variable by reference */
extern HB_EXPORT int hb_storvptr( void * pointer, int iParam, ... ); /* stores a pointer on a variable by reference */
extern HB_EXPORT int hb_storvptrGC( void * pointer, int iParam, ... ); /* stores a pointer to GC block on a variable by reference */
#ifndef HB_LONG_LONG_OFF
extern HB_EXPORT int hb_storvnll( HB_LONGLONG lValue, int iParam, ... ); /* stores a long long on a variable by reference */
extern HB_EXPORT int hb_storvnll( HB_LONGLONG llValue, int iParam, ... ); /* stores a long long on a variable by reference */
#endif
/* array management */
extern HB_EXPORT HB_BOOL hb_arrayNew( PHB_ITEM pItem, HB_SIZE ulLen ); /* creates a new array */
extern HB_EXPORT HB_BOOL hb_arrayNew( PHB_ITEM pItem, HB_SIZE nLen ); /* creates a new array */
extern HB_EXPORT HB_SIZE hb_arrayLen( PHB_ITEM pArray ); /* retrieves the array len */
extern HB_EXPORT HB_BOOL hb_arrayIsObject( PHB_ITEM pArray ); /* retrieves if the array is an object */
extern HB_EXPORT void * hb_arrayId( PHB_ITEM pArray ); /* retrieves the array unique ID */
extern HB_EXPORT HB_BOOL hb_arrayAdd( PHB_ITEM pArray, PHB_ITEM pItemValue ); /* add a new item to the end of an array item */
extern HB_EXPORT HB_BOOL hb_arrayAddForward( PHB_ITEM pArray, PHB_ITEM pValue ); /* add a new item to the end of an array item with no incrementing of reference counters */
extern HB_EXPORT HB_BOOL hb_arrayIns( PHB_ITEM pArray, HB_SIZE ulIndex ); /* insert a nil item into an array, without changing the length */
extern HB_EXPORT HB_BOOL hb_arrayDel( PHB_ITEM pArray, HB_SIZE ulIndex ); /* delete an array item, without changing length */
extern HB_EXPORT HB_BOOL hb_arraySize( PHB_ITEM pArray, HB_SIZE ulLen ); /* sets the array total length */
extern HB_EXPORT HB_BOOL hb_arrayIns( PHB_ITEM pArray, HB_SIZE nIndex ); /* insert a nil item into an array, without changing the length */
extern HB_EXPORT HB_BOOL hb_arrayDel( PHB_ITEM pArray, HB_SIZE nIndex ); /* delete an array item, without changing length */
extern HB_EXPORT HB_BOOL hb_arraySize( PHB_ITEM pArray, HB_SIZE nLen ); /* sets the array total length */
extern HB_EXPORT HB_BOOL hb_arrayLast( PHB_ITEM pArray, PHB_ITEM pResult ); /* retrieve last item in an array */
extern HB_EXPORT HB_BOOL hb_arrayGet( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem ); /* retrieves an item */
extern HB_EXPORT HB_BOOL hb_arrayGetItemRef( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem ); /* create a reference to an array element */
extern HB_EXPORT HB_BOOL hb_arrayGet( PHB_ITEM pArray, HB_SIZE nIndex, PHB_ITEM pItem ); /* retrieves an item */
extern HB_EXPORT HB_BOOL hb_arrayGetItemRef( PHB_ITEM pArray, HB_SIZE nIndex, PHB_ITEM pItem ); /* create a reference to an array element */
/* hb_arrayGetItemPtr() is dangerous, be sure that base ARRAY value will not be changed (f.e. resized) */
extern HB_EXPORT PHB_ITEM hb_arrayGetItemPtr( PHB_ITEM pArray, HB_SIZE ulIndex ); /* returns pointer to specified element of the array */
extern HB_EXPORT HB_SIZE hb_arrayCopyC( PHB_ITEM pArray, HB_SIZE ulIndex, char * szBuffer, HB_SIZE ulLen ); /* copy a string from an array item */
extern HB_EXPORT char * hb_arrayGetC( PHB_ITEM pArray, HB_SIZE ulIndex ); /* retrieves the string contained on an array element */
extern HB_EXPORT const char * hb_arrayGetCPtr( PHB_ITEM pArray, HB_SIZE ulIndex ); /* retrieves the string pointer on an array element */
extern HB_EXPORT HB_SIZE hb_arrayGetCLen( PHB_ITEM pArray, HB_SIZE ulIndex ); /* retrieves the string length contained on an array element */
extern HB_EXPORT void * hb_arrayGetPtr( PHB_ITEM pArray, HB_SIZE ulIndex ); /* retrieves the pointer contained on an array element */
extern HB_EXPORT void * hb_arrayGetPtrGC( PHB_ITEM pArray, HB_SIZE ulIndex, const HB_GC_FUNCS * pFuncs ); /* retrieves the GC pointer contained on an array element */
extern HB_EXPORT PHB_SYMB hb_arrayGetSymbol( PHB_ITEM pArray, HB_SIZE ulIndex ); /* retrieves symbol contained on an array element */
extern HB_EXPORT HB_BOOL hb_arrayGetL( PHB_ITEM pArray, HB_SIZE ulIndex ); /* retrieves the logical value contained on an array element */
extern HB_EXPORT int hb_arrayGetNI( PHB_ITEM pArray, HB_SIZE ulIndex ); /* retrieves the int value contained on an array element */
extern HB_EXPORT long hb_arrayGetNL( PHB_ITEM pArray, HB_SIZE ulIndex ); /* retrieves the long numeric value contained on an array element */
extern HB_EXPORT HB_ISIZ hb_arrayGetNS( PHB_ITEM pArray, HB_SIZE ulIndex ); /* retrieves the HB_SIZE value contained on an array element */
extern HB_EXPORT HB_MAXINT hb_arrayGetNInt( PHB_ITEM pArray, HB_SIZE ulIndex ); /* retrieves the HB_MAXINT value contained on an array element */
extern HB_EXPORT double hb_arrayGetND( PHB_ITEM pArray, HB_SIZE ulIndex ); /* retrieves the double value contained on an array element */
extern HB_EXPORT char * hb_arrayGetDS( PHB_ITEM pArray, HB_SIZE ulIndex, char * szDate ); /* retrieves the date value contained in an array element */
extern HB_EXPORT long hb_arrayGetDL( PHB_ITEM pArray, HB_SIZE ulIndex ); /* retrieves the date value contained in an array element, as a long integer */
extern HB_EXPORT double hb_arrayGetTD( PHB_ITEM pArray, HB_SIZE ulIndex ); /* retrieves the timestamp value contained in an array element, as a double value */
extern HB_EXPORT HB_BOOL hb_arrayGetTDT( PHB_ITEM pArray, HB_SIZE ulIndex, long * plJulian, long * plMilliSec ); /* retrieves the timestamp value contained in an array element, as two long values */
extern HB_EXPORT HB_TYPE hb_arrayGetType( PHB_ITEM pArray, HB_SIZE ulIndex ); /* retrieves the type of an array item */
extern HB_EXPORT HB_BOOL hb_arraySet( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem ); /* sets an array element */
extern HB_EXPORT HB_BOOL hb_arraySetForward( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem ); /* sets an array element by forwarding it's value */
extern HB_EXPORT HB_BOOL hb_arraySetDS( PHB_ITEM pArray, HB_SIZE ulIndex, const char * szDate );
extern HB_EXPORT HB_BOOL hb_arraySetDL( PHB_ITEM pArray, HB_SIZE ulIndex, long lDate );
extern HB_EXPORT HB_BOOL hb_arraySetTD( PHB_ITEM pArray, HB_SIZE ulIndex, double dTimeStamp );
extern HB_EXPORT HB_BOOL hb_arraySetTDT( PHB_ITEM pArray, HB_SIZE ulIndex, long lJulian, long lMilliSec );
extern HB_EXPORT HB_BOOL hb_arraySetL( PHB_ITEM pArray, HB_SIZE ulIndex, HB_BOOL fValue );
extern HB_EXPORT HB_BOOL hb_arraySetNI( PHB_ITEM pArray, HB_SIZE ulIndex, int iNumber );
extern HB_EXPORT HB_BOOL hb_arraySetNL( PHB_ITEM pArray, HB_SIZE ulIndex, long lNumber );
extern HB_EXPORT HB_BOOL hb_arraySetNS( PHB_ITEM pArray, HB_SIZE ulIndex, HB_ISIZ nNumber );
extern HB_EXPORT PHB_ITEM hb_arrayGetItemPtr( PHB_ITEM pArray, HB_SIZE nIndex ); /* returns pointer to specified element of the array */
extern HB_EXPORT HB_SIZE hb_arrayCopyC( PHB_ITEM pArray, HB_SIZE nIndex, char * szBuffer, HB_SIZE nLen ); /* copy a string from an array item */
extern HB_EXPORT char * hb_arrayGetC( PHB_ITEM pArray, HB_SIZE nIndex ); /* retrieves the string contained on an array element */
extern HB_EXPORT const char * hb_arrayGetCPtr( PHB_ITEM pArray, HB_SIZE nIndex ); /* retrieves the string pointer on an array element */
extern HB_EXPORT HB_SIZE hb_arrayGetCLen( PHB_ITEM pArray, HB_SIZE nIndex ); /* retrieves the string length contained on an array element */
extern HB_EXPORT void * hb_arrayGetPtr( PHB_ITEM pArray, HB_SIZE nIndex ); /* retrieves the pointer contained on an array element */
extern HB_EXPORT void * hb_arrayGetPtrGC( PHB_ITEM pArray, HB_SIZE nIndex, const HB_GC_FUNCS * pFuncs ); /* retrieves the GC pointer contained on an array element */
extern HB_EXPORT PHB_SYMB hb_arrayGetSymbol( PHB_ITEM pArray, HB_SIZE nIndex ); /* retrieves symbol contained on an array element */
extern HB_EXPORT HB_BOOL hb_arrayGetL( PHB_ITEM pArray, HB_SIZE nIndex ); /* retrieves the logical value contained on an array element */
extern HB_EXPORT int hb_arrayGetNI( PHB_ITEM pArray, HB_SIZE nIndex ); /* retrieves the int value contained on an array element */
extern HB_EXPORT long hb_arrayGetNL( PHB_ITEM pArray, HB_SIZE nIndex ); /* retrieves the long numeric value contained on an array element */
extern HB_EXPORT HB_ISIZ hb_arrayGetNS( PHB_ITEM pArray, HB_SIZE nIndex ); /* retrieves the HB_SIZE value contained on an array element */
extern HB_EXPORT HB_MAXINT hb_arrayGetNInt( PHB_ITEM pArray, HB_SIZE nIndex ); /* retrieves the HB_MAXINT value contained on an array element */
extern HB_EXPORT double hb_arrayGetND( PHB_ITEM pArray, HB_SIZE nIndex ); /* retrieves the double value contained on an array element */
extern HB_EXPORT char * hb_arrayGetDS( PHB_ITEM pArray, HB_SIZE nIndex, char * szDate ); /* retrieves the date value contained in an array element */
extern HB_EXPORT long hb_arrayGetDL( PHB_ITEM pArray, HB_SIZE nIndex ); /* retrieves the date value contained in an array element, as a long integer */
extern HB_EXPORT double hb_arrayGetTD( PHB_ITEM pArray, HB_SIZE nIndex ); /* retrieves the timestamp value contained in an array element, as a double value */
extern HB_EXPORT HB_BOOL hb_arrayGetTDT( PHB_ITEM pArray, HB_SIZE nIndex, long * plJulian, long * plMilliSec ); /* retrieves the timestamp value contained in an array element, as two long values */
extern HB_EXPORT HB_TYPE hb_arrayGetType( PHB_ITEM pArray, HB_SIZE nIndex ); /* retrieves the type of an array item */
extern HB_EXPORT HB_BOOL hb_arraySet( PHB_ITEM pArray, HB_SIZE nIndex, PHB_ITEM pItem ); /* sets an array element */
extern HB_EXPORT HB_BOOL hb_arraySetForward( PHB_ITEM pArray, HB_SIZE nIndex, PHB_ITEM pItem ); /* sets an array element by forwarding it's value */
extern HB_EXPORT HB_BOOL hb_arraySetDS( PHB_ITEM pArray, HB_SIZE nIndex, const char * szDate );
extern HB_EXPORT HB_BOOL hb_arraySetDL( PHB_ITEM pArray, HB_SIZE nIndex, long lDate );
extern HB_EXPORT HB_BOOL hb_arraySetTD( PHB_ITEM pArray, HB_SIZE nIndex, double dTimeStamp );
extern HB_EXPORT HB_BOOL hb_arraySetTDT( PHB_ITEM pArray, HB_SIZE nIndex, long lJulian, long lMilliSec );
extern HB_EXPORT HB_BOOL hb_arraySetL( PHB_ITEM pArray, HB_SIZE nIndex, HB_BOOL fValue );
extern HB_EXPORT HB_BOOL hb_arraySetNI( PHB_ITEM pArray, HB_SIZE nIndex, int iNumber );
extern HB_EXPORT HB_BOOL hb_arraySetNL( PHB_ITEM pArray, HB_SIZE nIndex, long lNumber );
extern HB_EXPORT HB_BOOL hb_arraySetNS( PHB_ITEM pArray, HB_SIZE nIndex, HB_ISIZ nNumber );
#ifndef HB_LONG_LONG_OFF
extern HB_EXPORT HB_BOOL hb_arraySetNLL( PHB_ITEM pArray, HB_SIZE ulIndex, HB_LONGLONG llNumber );
extern HB_EXPORT HB_BOOL hb_arraySetNLL( PHB_ITEM pArray, HB_SIZE nIndex, HB_LONGLONG llNumber );
#endif
extern HB_EXPORT HB_BOOL hb_arraySetNInt( PHB_ITEM pArray, HB_SIZE ulIndex, HB_MAXINT lNumber );
extern HB_EXPORT HB_BOOL hb_arraySetND( PHB_ITEM pArray, HB_SIZE ulIndex, double dNumber );
extern HB_EXPORT HB_BOOL hb_arraySetC( PHB_ITEM pArray, HB_SIZE ulIndex, const char * szText );
extern HB_EXPORT HB_BOOL hb_arraySetCL( PHB_ITEM pArray, HB_SIZE ulIndex, const char * szText, HB_SIZE ulLen );
extern HB_EXPORT HB_BOOL hb_arraySetCLPtr( PHB_ITEM pArray, HB_SIZE ulIndex, char * szText, HB_SIZE ulLen );
extern HB_EXPORT HB_BOOL hb_arraySetPtr( PHB_ITEM pArray, HB_SIZE ulIndex, void * pValue );
extern HB_EXPORT HB_BOOL hb_arraySetPtrGC( PHB_ITEM pArray, HB_SIZE ulIndex, void * pValue );
extern HB_EXPORT HB_BOOL hb_arraySetSymbol( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_SYMB pSymbol );
extern HB_EXPORT HB_BOOL hb_arrayFill( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pulStart, HB_SIZE * pulCount ); /* fill an array with a given item */
extern HB_EXPORT HB_SIZE hb_arrayScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pulStart, HB_SIZE * pulCount, HB_BOOL fExact ); /* scan an array for a given item, or until code-block item returns HB_TRUE */
extern HB_EXPORT HB_SIZE hb_arrayRevScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pulStart, HB_SIZE * pulCount, HB_BOOL fExact ); /* scan an array for a given item, or until code-block item returns HB_TRUE in reverted order */
extern HB_EXPORT HB_BOOL hb_arrayEval( PHB_ITEM pArray, PHB_ITEM bBlock, HB_SIZE * pulStart, HB_SIZE * pulCount ); /* execute a code-block for every element of an array item */
extern HB_EXPORT HB_BOOL hb_arrayCopy( PHB_ITEM pSrcArray, PHB_ITEM pDstArray, HB_SIZE * pulStart, HB_SIZE * pulCount, HB_SIZE * pulTarget ); /* copy items from one array to another */
extern HB_EXPORT HB_BOOL hb_arraySetNInt( PHB_ITEM pArray, HB_SIZE nIndex, HB_MAXINT lNumber );
extern HB_EXPORT HB_BOOL hb_arraySetND( PHB_ITEM pArray, HB_SIZE nIndex, double dNumber );
extern HB_EXPORT HB_BOOL hb_arraySetC( PHB_ITEM pArray, HB_SIZE nIndex, const char * szText );
extern HB_EXPORT HB_BOOL hb_arraySetCL( PHB_ITEM pArray, HB_SIZE nIndex, const char * szText, HB_SIZE nLen );
extern HB_EXPORT HB_BOOL hb_arraySetCLPtr( PHB_ITEM pArray, HB_SIZE nIndex, char * szText, HB_SIZE nLen );
extern HB_EXPORT HB_BOOL hb_arraySetPtr( PHB_ITEM pArray, HB_SIZE nIndex, void * pValue );
extern HB_EXPORT HB_BOOL hb_arraySetPtrGC( PHB_ITEM pArray, HB_SIZE nIndex, void * pValue );
extern HB_EXPORT HB_BOOL hb_arraySetSymbol( PHB_ITEM pArray, HB_SIZE nIndex, PHB_SYMB pSymbol );
extern HB_EXPORT HB_BOOL hb_arrayFill( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pnStart, HB_SIZE * pnCount ); /* fill an array with a given item */
extern HB_EXPORT HB_SIZE hb_arrayScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pnStart, HB_SIZE * pnCount, HB_BOOL fExact ); /* scan an array for a given item, or until code-block item returns HB_TRUE */
extern HB_EXPORT HB_SIZE hb_arrayRevScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pnStart, HB_SIZE * pnCount, HB_BOOL fExact ); /* scan an array for a given item, or until code-block item returns HB_TRUE in reverted order */
extern HB_EXPORT HB_BOOL hb_arrayEval( PHB_ITEM pArray, PHB_ITEM bBlock, HB_SIZE * pnStart, HB_SIZE * pnCount ); /* execute a code-block for every element of an array item */
extern HB_EXPORT HB_BOOL hb_arrayCopy( PHB_ITEM pSrcArray, PHB_ITEM pDstArray, HB_SIZE * pnStart, HB_SIZE * pnCount, HB_SIZE * pnTarget ); /* copy items from one array to another */
extern HB_EXPORT PHB_ITEM hb_arrayClone( PHB_ITEM pArray ); /* returns a duplicate of an existing array, including all nested items */
extern HB_EXPORT PHB_ITEM hb_arrayCloneTo( PHB_ITEM pDest, PHB_ITEM pArray ); /* returns a duplicate of an existing array, including all nested items */
extern HB_EXPORT HB_BOOL hb_arraySort( PHB_ITEM pArray, HB_SIZE * pulStart, HB_SIZE * pulCount, PHB_ITEM pBlock ); /* sorts an array item */
extern HB_EXPORT HB_BOOL hb_arraySort( PHB_ITEM pArray, HB_SIZE * pnStart, HB_SIZE * pnCount, PHB_ITEM pBlock ); /* sorts an array item */
extern HB_EXPORT PHB_ITEM hb_arrayFromStack( HB_USHORT uiLen ); /* Creates and returns an Array of n Elements from the Eval Stack - Does NOT pop the items. */
extern HB_EXPORT PHB_ITEM hb_arrayFromParams( int iLevel ); /* Creates and returns an Array of Generic Parameters for a given call level */
extern HB_EXPORT PHB_ITEM hb_arrayBaseParams( void ); /* Creates and returns an Array of Generic Parameters for current base symbol. */
extern HB_EXPORT PHB_ITEM hb_arraySelfParams( void ); /* Creates and returns an Array of Generic Parameters for current base symbol with self item */
#ifndef HB_LONG_LONG_OFF
extern HB_EXPORT HB_LONGLONG hb_arrayGetNLL( PHB_ITEM pArray, HB_SIZE ulIndex ); /* retrieves the long long numeric value contained on an array element */
extern HB_EXPORT HB_LONGLONG hb_arrayGetNLL( PHB_ITEM pArray, HB_SIZE nIndex ); /* retrieves the long long numeric value contained on an array element */
#endif
#ifdef _HB_API_INTERNAL_
/* internal array API not exported */
@@ -870,8 +870,8 @@ extern HB_EXPORT void hb_hashSort( PHB_ITEM pHash );
extern HB_EXPORT PHB_ITEM hb_hashClone( PHB_ITEM pHash );
extern HB_EXPORT PHB_ITEM hb_hashCloneTo( PHB_ITEM pDest, PHB_ITEM pHash );
extern HB_EXPORT void hb_hashJoin( PHB_ITEM pDest, PHB_ITEM pSource, int iType );
extern HB_EXPORT HB_BOOL hb_hashScan( PHB_ITEM pHash, PHB_ITEM pKey, HB_SIZE * pulPos );
extern HB_EXPORT void hb_hashPreallocate( PHB_ITEM pHash, HB_SIZE ulNewSize );
extern HB_EXPORT HB_BOOL hb_hashScan( PHB_ITEM pHash, PHB_ITEM pKey, HB_SIZE * pnPos );
extern HB_EXPORT void hb_hashPreallocate( PHB_ITEM pHash, HB_SIZE nNewSize );
extern HB_EXPORT PHB_ITEM hb_hashGetKeys( PHB_ITEM pHash );
extern HB_EXPORT PHB_ITEM hb_hashGetValues( PHB_ITEM pHash );
extern HB_EXPORT void hb_hashSetDefault( PHB_ITEM pHash, PHB_ITEM pValue );
@@ -886,10 +886,10 @@ extern HB_EXPORT PHB_ITEM hb_hashGetItemPtr( PHB_ITEM pHash, PHB_ITEM pKey, int
extern HB_EXPORT PHB_ITEM hb_hashGetItemRefPtr( PHB_ITEM pHash, PHB_ITEM pKey );
extern HB_EXPORT PHB_ITEM hb_hashGetCItemPtr( PHB_ITEM pHash, const char * pszKey );
extern HB_EXPORT HB_SIZE hb_hashGetCItemPos( PHB_ITEM pHash, const char * pszKey );
extern HB_EXPORT PHB_ITEM hb_hashGetKeyAt( PHB_ITEM pHash, HB_SIZE ulPos );
extern HB_EXPORT PHB_ITEM hb_hashGetValueAt( PHB_ITEM pHash, HB_SIZE ulPos );
extern HB_EXPORT PHB_ITEM hb_hashGetKeyAt( PHB_ITEM pHash, HB_SIZE nPos );
extern HB_EXPORT PHB_ITEM hb_hashGetValueAt( PHB_ITEM pHash, HB_SIZE nPos );
extern HB_EXPORT HB_BOOL hb_hashDelAt( PHB_ITEM pHash, HB_SIZE ulPos );
extern HB_EXPORT HB_BOOL hb_hashDelAt( PHB_ITEM pHash, HB_SIZE nPos );
/* hash item flags */
#define HB_HASH_AUTOADD_NEVER 0x00
@@ -919,20 +919,20 @@ extern HB_EXPORT HB_BOOL hb_hashDelAt( PHB_ITEM pHash, HB_SIZE ulPos );
extern const char * hb_szAscii[ 256 ]; /* array of 1 character length strings */
extern HB_EXPORT int hb_stricmp( const char * s1, const char * s2 ); /* compare two strings without regards to case */
extern HB_EXPORT int hb_strnicmp( const char * s1, const char * s2, HB_SIZE ulLen ); /* compare two string without regards to case, limited by length */
extern HB_EXPORT int hb_strnicmp( const char * s1, const char * s2, HB_SIZE nLen ); /* compare two string without regards to case, limited by length */
extern HB_EXPORT char * hb_strupr( char * pszText ); /* convert a string in-place to upper-case */
extern HB_EXPORT char * hb_strlow( char * pszText ); /* convert a string in-place to lower-case */
extern HB_EXPORT char * hb_strdup( const char * pszText ); /* returns a pointer to a newly allocated copy of the source string */
extern HB_EXPORT char * hb_strndup( const char * pszText, HB_SIZE ulLen ); /* returns a pointer to a newly allocated copy of the source string not longer then ulLen */
extern HB_EXPORT char * hb_strndup( const char * pszText, HB_SIZE nLen ); /* returns a pointer to a newly allocated copy of the source string not longer then nLen */
extern HB_EXPORT char * hb_strduptrim( const char * pszText ); /* returns a pointer to a newly allocated copy of the trimmed source string */
extern HB_EXPORT HB_SIZE hb_strlentrim( const char * pszText ); /* like strlen() but result is the length of trimmed text */
extern HB_EXPORT HB_SIZE hb_strnlen( const char * pszText, HB_SIZE ulLen ); /* like strlen() but result is limited to ulLen */
extern HB_EXPORT HB_SIZE hb_strnlen( const char * pszText, HB_SIZE nLen ); /* like strlen() but result is limited to nLen */
extern HB_EXPORT char * hb_xstrcat( char * dest, const char * src, ... ); /* Concatenates multiple strings into a single result */
extern HB_EXPORT char * hb_xstrcpy( char * szDest, const char * szSrc, ... ); /* Concatenates multiple strings into a single result */
extern HB_EXPORT HB_BOOL hb_compStrToNum( const char * szNum, HB_SIZE ulLen, HB_MAXINT * plVal, double * pdVal, int * piDec, int * piWidth ); /* converts string to number, sets iDec, iWidth and returns HB_TRUE if results is double, used by compiler */
extern HB_EXPORT HB_BOOL hb_valStrnToNum( const char * szNum, HB_SIZE ulLen, HB_MAXINT * plVal, double * pdVal, int * piDec, int * piWidth ); /* converts string to number, sets iDec, iWidth and returns HB_TRUE if results is double, used by VAL() */
extern HB_EXPORT HB_BOOL hb_strToNum( const char * szNum, HB_MAXINT * plVal, double * pdVal ); /* converts string to number, returns HB_TRUE if results is double */
extern HB_EXPORT HB_BOOL hb_strnToNum( const char * szNum, HB_SIZE ulLen, HB_MAXINT * plVal, double * pdVal ); /* converts string to number, returns HB_TRUE if results is double */
extern HB_EXPORT HB_BOOL hb_compStrToNum( const char * szNum, HB_SIZE nLen, HB_MAXINT * pnVal, double * pdVal, int * piDec, int * piWidth ); /* converts string to number, sets iDec, iWidth and returns HB_TRUE if results is double, used by compiler */
extern HB_EXPORT HB_BOOL hb_valStrnToNum( const char * szNum, HB_SIZE nLen, HB_MAXINT * pnVal, double * pdVal, int * piDec, int * piWidth ); /* converts string to number, sets iDec, iWidth and returns HB_TRUE if results is double, used by VAL() */
extern HB_EXPORT HB_BOOL hb_strToNum( const char * szNum, HB_MAXINT * pnVal, double * pdVal ); /* converts string to number, returns HB_TRUE if results is double */
extern HB_EXPORT HB_BOOL hb_strnToNum( const char * szNum, HB_SIZE nLen, HB_MAXINT * pnVal, double * pdVal ); /* converts string to number, returns HB_TRUE if results is double */
extern HB_EXPORT int hb_snprintf( char * buffer, size_t bufsize, const char * format, ... ) HB_PRINTF_FORMAT( 3, 4 ); /* snprintf() equivalent */
extern HB_EXPORT int hb_vsnprintf( char * buffer, size_t bufsize, const char * format, va_list ap ); /* vsnprintf() equivalent */
extern HB_EXPORT int hb_printf_params( const char * format );
@@ -942,30 +942,30 @@ extern HB_EXPORT HB_BOOL hb_strMatchRegExp( const char * szString, const char
extern HB_EXPORT HB_BOOL hb_strMatchWild( const char * szString, const char * szPattern ); /* compare two strings using pattern with wildcard (?*) - patern have to be prefix of given string */
extern HB_EXPORT HB_BOOL hb_strMatchWildExact( const char * szString, const char * szPattern ); /* compare two strings using pattern with wildcard (?*) - patern have to cover whole string */
extern HB_EXPORT HB_BOOL hb_strMatchCaseWildExact( const char * szString, const char * szPattern ); /* compare two strings using pattern with wildcard (?*) ignoring the case of the characters - patern have to cover whole string */
extern HB_EXPORT HB_BOOL hb_strEmpty( const char * szText, HB_SIZE ulLen ); /* returns whether a string contains only white space */
extern HB_EXPORT void hb_strDescend( char * szStringTo, const char * szStringFrom, HB_SIZE ulLen ); /* copy a string to a buffer, inverting each character */
extern HB_EXPORT HB_SIZE hb_strAt( const char * szSub, HB_SIZE ulSubLen, const char * szText, HB_SIZE ulLen ); /* returns an index to a sub-string within another string */
extern HB_EXPORT char * hb_strUpper( char * szText, HB_SIZE ulLen ); /* convert an existing string buffer to upper case */
extern HB_EXPORT char * hb_strLower( char * szText, HB_SIZE ulLen ); /* convert an existing string buffer to lower case */
extern HB_EXPORT HB_BOOL hb_strEmpty( const char * szText, HB_SIZE nLen ); /* returns whether a string contains only white space */
extern HB_EXPORT void hb_strDescend( char * szStringTo, const char * szStringFrom, HB_SIZE nLen ); /* copy a string to a buffer, inverting each character */
extern HB_EXPORT HB_SIZE hb_strAt( const char * szSub, HB_SIZE nSubLen, const char * szText, HB_SIZE nLen ); /* returns an index to a sub-string within another string */
extern HB_EXPORT char * hb_strUpper( char * szText, HB_SIZE nLen ); /* convert an existing string buffer to upper case */
extern HB_EXPORT char * hb_strLower( char * szText, HB_SIZE nLen ); /* convert an existing string buffer to lower case */
extern HB_EXPORT HB_BOOL hb_charIsDigit( int iChar );
extern HB_EXPORT HB_BOOL hb_charIsAlpha( int iChar );
extern HB_EXPORT HB_BOOL hb_charIsLower( int iChar );
extern HB_EXPORT HB_BOOL hb_charIsUpper( int iChar );
extern HB_EXPORT int hb_charUpper( int iChar ); /* converts iChar to upper case */
extern HB_EXPORT int hb_charLower( int iChar ); /* converts iChar to lower case */
extern HB_EXPORT char * hb_strncpy( char * pDest, const char * pSource, HB_SIZE ulLen ); /* copy at most ulLen bytes from string buffer to another buffer and _always_ set 0 in destin buffer */
extern HB_EXPORT char * hb_strncat( char * pDest, const char * pSource, HB_SIZE ulLen ); /* copy at most ulLen-strlen(pDest) bytes from string buffer to another buffer and _always_ set 0 in destin buffer */
extern HB_EXPORT char * hb_strncpyTrim( char * pDest, const char * pSource, HB_SIZE ulLen );
extern HB_EXPORT char * hb_strncpyLower( char * pDest, const char * pSource, HB_SIZE ulLen ); /* copy an existing string buffer to another buffer, as lower case */
extern HB_EXPORT char * hb_strncpyUpper( char * pDest, const char * pSource, HB_SIZE ulLen ); /* copy an existing string buffer to another buffer, as upper case */
extern HB_EXPORT char * hb_strncpyUpperTrim( char * pDest, const char * pSource, HB_SIZE ulLen );
extern HB_EXPORT double hb_strVal( const char * szText, HB_SIZE ulLen ); /* return the numeric value of a character string representation of a number */
extern HB_EXPORT const char * hb_strLTrim( const char * szText, HB_SIZE * ulLen ); /* return a pointer to the first non-white space character */
extern HB_EXPORT HB_SIZE hb_strRTrimLen( const char * szText, HB_SIZE ulLen, HB_BOOL bAnySpace ); /* return length of a string, ignoring trailing white space (or true spaces) */
extern HB_EXPORT double hb_strVal( const char * szText, HB_SIZE ulLen );
extern HB_EXPORT char * hb_strncpy( char * pDest, const char * pSource, HB_SIZE nLen ); /* copy at most nLen bytes from string buffer to another buffer and _always_ set 0 in destin buffer */
extern HB_EXPORT char * hb_strncat( char * pDest, const char * pSource, HB_SIZE nLen ); /* copy at most nLen-strlen(pDest) bytes from string buffer to another buffer and _always_ set 0 in destin buffer */
extern HB_EXPORT char * hb_strncpyTrim( char * pDest, const char * pSource, HB_SIZE nLen );
extern HB_EXPORT char * hb_strncpyLower( char * pDest, const char * pSource, HB_SIZE nLen ); /* copy an existing string buffer to another buffer, as lower case */
extern HB_EXPORT char * hb_strncpyUpper( char * pDest, const char * pSource, HB_SIZE nLen ); /* copy an existing string buffer to another buffer, as upper case */
extern HB_EXPORT char * hb_strncpyUpperTrim( char * pDest, const char * pSource, HB_SIZE nLen );
extern HB_EXPORT double hb_strVal( const char * szText, HB_SIZE nLen ); /* return the numeric value of a character string representation of a number */
extern HB_EXPORT const char * hb_strLTrim( const char * szText, HB_SIZE * nLen ); /* return a pointer to the first non-white space character */
extern HB_EXPORT HB_SIZE hb_strRTrimLen( const char * szText, HB_SIZE nLen, HB_BOOL bAnySpace ); /* return length of a string, ignoring trailing white space (or true spaces) */
extern HB_EXPORT double hb_strVal( const char * szText, HB_SIZE nLen );
extern HB_EXPORT HB_MAXINT hb_strValInt( const char * szText, int * iOverflow );
extern HB_EXPORT char * hb_strRemEscSeq( char * szText, HB_SIZE * ulLen ); /* remove C ESC sequences and converts them to Clipper chars */
extern HB_EXPORT char * hb_numToStr( char * szBuf, HB_SIZE ulSize, HB_MAXINT lNumber );
extern HB_EXPORT char * hb_strRemEscSeq( char * szText, HB_SIZE * nLen ); /* remove C ESC sequences and converts them to Clipper chars */
extern HB_EXPORT char * hb_numToStr( char * szBuf, HB_SIZE nSize, HB_MAXINT lNumber );
extern HB_EXPORT double hb_numRound( double dResult, int iDec ); /* round a number to a specific number of digits */
extern HB_EXPORT double hb_numInt( double dNum ); /* take the integer part of the number */
extern HB_EXPORT double hb_random_num( void );
@@ -1033,8 +1033,8 @@ extern HB_EXPORT HB_BOOL hb_winmainArgGet( void * phInstance, void * phPrevInsta
/* Codeblock management */
extern HB_EXPORT void * hb_codeblockId( PHB_ITEM pItem ); /* retrieves the codeblock unique ID */
extern HB_CODEBLOCK_PTR hb_codeblockNew( const HB_BYTE * pBuffer, HB_USHORT uiLocals, const HB_BYTE * pLocalPosTable, PHB_SYMB pSymbols, HB_SIZE ulLen ); /* create a code-block */
extern HB_CODEBLOCK_PTR hb_codeblockMacroNew( const HB_BYTE * pBuffer, HB_SIZE ulLen );
extern HB_CODEBLOCK_PTR hb_codeblockNew( const HB_BYTE * pBuffer, HB_USHORT uiLocals, const HB_BYTE * pLocalPosTable, PHB_SYMB pSymbols, HB_SIZE nLen ); /* create a code-block */
extern HB_CODEBLOCK_PTR hb_codeblockMacroNew( const HB_BYTE * pBuffer, HB_SIZE nLen );
extern PHB_ITEM hb_codeblockGetVar( PHB_ITEM pItem, int iItemPos ); /* get local variable referenced in a codeblock */
extern PHB_ITEM hb_codeblockGetRef( HB_CODEBLOCK_PTR pCBlock, int iItemPos ); /* get local variable passed by reference */
@@ -1045,12 +1045,12 @@ extern HB_EXPORT HB_ERRCODE hb_memvarGet( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSym
extern void hb_memvarGetValue( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb ); /* copy an symbol value into an item, with error trapping */
extern void hb_memvarGetRefer( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb ); /* copy a reference to a symbol value into an item, with error trapping */
extern HB_SIZE hb_memvarGetPrivatesBase( void ); /* retrieve current PRIVATE variables stack base */
extern void hb_memvarSetPrivatesBase( HB_SIZE ulBase ); /* release PRIVATE variables created after specified base */
extern void hb_memvarSetPrivatesBase( HB_SIZE nBase ); /* release PRIVATE variables created after specified base */
extern void hb_memvarUpdatePrivatesBase( void ); /* Update PRIVATE base ofsset so they will not be removed when function return */
extern void hb_memvarNewParameter( PHB_SYMB pSymbol, PHB_ITEM pValue );
extern char * hb_memvarGetStrValuePtr( char * szVarName, HB_SIZE * pulLen );
extern char * hb_memvarGetStrValuePtr( char * szVarName, HB_SIZE * pnLen );
extern void hb_memvarCreateFromItem( PHB_ITEM pMemvar, int iScope, PHB_ITEM pValue );
extern int hb_memvarScope( const char * szVarName, HB_SIZE ulLength ); /* retrieve scope of a dynamic variable symbol */
extern int hb_memvarScope( const char * szVarName, HB_SIZE nLength ); /* retrieve scope of a dynamic variable symbol */
extern PHB_ITEM hb_memvarDetachLocal( HB_ITEM_PTR pLocal ); /* Detach a local variable from the eval stack */
extern PHB_ITEM hb_memvarGetValueBySym( PHB_DYNS pDynSym );
extern PHB_ITEM hb_memvarSaveInArray( int iScope, HB_BOOL fCopy ); /* create array with visible memvar references or copies respecting given memvars scope */
@@ -1069,15 +1069,15 @@ extern PHB_ITEM hb_memvarGetItem( PHB_SYMB pMemvarSymb );
extern void hb_conInit( void ); /* initialize the console API system */
extern void hb_conRelease( void ); /* release the console API system */
extern HB_EXPORT const char * hb_conNewLine( void ); /* retrieve a pointer to a static buffer containing new-line characters */
extern HB_EXPORT void hb_conOutStd( const char * pStr, HB_SIZE ulLen ); /* output an string to STDOUT */
extern HB_EXPORT void hb_conOutErr( const char * pStr, HB_SIZE ulLen ); /* output an string to STDERR */
extern HB_EXPORT void hb_conOutAlt( const char * pStr, HB_SIZE ulLen ); /* output an string to the screen and/or printer and/or alternate */
extern HB_EXPORT void hb_conOutStd( const char * pStr, HB_SIZE nLen ); /* output an string to STDOUT */
extern HB_EXPORT void hb_conOutErr( const char * pStr, HB_SIZE nLen ); /* output an string to STDERR */
extern HB_EXPORT void hb_conOutAlt( const char * pStr, HB_SIZE nLen ); /* output an string to the screen and/or printer and/or alternate */
extern HB_EXPORT int hb_conSetCursor( HB_BOOL bSetCursor, int iNewCursor ); /* retrieve and optionally set cursor shape */
extern HB_EXPORT const char * hb_conSetColor( const char * szColor ); /* retrieve and optionally set console color */
/* compiler and macro compiler */
extern char * hb_compEncodeString( int iMethod, const char * szText, HB_SIZE * pulLen );
extern char * hb_compDecodeString( int iMethod, const char * szText, HB_SIZE * pulLen );
extern char * hb_compEncodeString( int iMethod, const char * szText, HB_SIZE * pnLen );
extern char * hb_compDecodeString( int iMethod, const char * szText, HB_SIZE * pnLen );
/* misc */
extern char * hb_procname( int iLevel, char * szName, HB_BOOL bskipBlock ); /* retrieve a procedure name into a buffer */
@@ -1098,8 +1098,8 @@ extern void hb_macroPushSymbol( HB_ITEM_PTR pItem ); /* handle a macro functio
extern void hb_macroRun( HB_MACRO_PTR pMacro ); /* executes pcode compiled by macro compiler */
extern HB_MACRO_PTR hb_macroCompile( const char * szString ); /* compile a string and return a pcode buffer */
extern void hb_macroDelete( HB_MACRO_PTR pMacro ); /* release all memory allocated for macro evaluation */
extern char * hb_macroTextSymbol( const char * szString, HB_SIZE ulLength, HB_BOOL * pfNewString ); /* substitute macro variables occurences within a given string and check if result is a valid function or variable name */
extern char * hb_macroExpandString( const char * szString, HB_SIZE ulLength, HB_BOOL * pfNewString ); /* expands valid '&' operator */
extern char * hb_macroTextSymbol( const char * szString, HB_SIZE nLength, HB_BOOL * pfNewString ); /* substitute macro variables occurences within a given string and check if result is a valid function or variable name */
extern char * hb_macroExpandString( const char * szString, HB_SIZE nLength, HB_BOOL * pfNewString ); /* expands valid '&' operator */
extern void hb_macroPopAliasedValue( HB_ITEM_PTR pAlias, HB_ITEM_PTR pVar, int flags ); /* compiles and evaluates an aliased macro expression */
extern void hb_macroPushAliasedValue( HB_ITEM_PTR pAlias, HB_ITEM_PTR pVar, int flags ); /* compiles and evaluates an aliased macro expression */
extern const char * hb_macroGetType( HB_ITEM_PTR pItem ); /* determine the type of an expression */
@@ -1161,8 +1161,8 @@ extern HB_EXPORT HB_BOOL hb_iswince( void ); /* return HB_TRUE if OS is Windo
extern HB_EXPORT HB_BOOL hb_printerIsReady( const char * pszPrinterName );
/* OS/Harbour codepage conversion */
extern HB_EXPORT const char * hb_osEncodeCP( const char * szName, char ** pszFree, HB_SIZE * pulSize ); /* Convert a string sent to a system call, from Harbour codepage. */
extern HB_EXPORT const char * hb_osDecodeCP( const char * szName, char ** pszFree, HB_SIZE * pulSize ); /* Convert a string received from a system call, to Harbour codepage. */
extern HB_EXPORT const char * hb_osEncodeCP( const char * szName, char ** pszFree, HB_SIZE * pnSize ); /* Convert a string sent to a system call, from Harbour codepage. */
extern HB_EXPORT const char * hb_osDecodeCP( const char * szName, char ** pszFree, HB_SIZE * pnSize ); /* Convert a string received from a system call, to Harbour codepage. */
/* environment variables access */
extern HB_BOOL hb_getenv_buffer( const char * szName, char * szBuffer, int nSize );

30
harbour/include/hbapicdp.h
View File

@@ -347,8 +347,8 @@ extern HB_EXPORT HB_BOOL hb_cdpIsDigit( PHB_CODEPAGE cdp, int iChar );
extern HB_EXPORT HB_BOOL hb_cdpIsAlpha( PHB_CODEPAGE cdp, int iChar );
extern HB_EXPORT HB_BOOL hb_cdpIsLower( PHB_CODEPAGE cdp, int iChar );
extern HB_EXPORT HB_BOOL hb_cdpIsUpper( PHB_CODEPAGE cdp, int iChar );
extern HB_EXPORT int hb_cdpcmp( const char * szFirst, HB_SIZE ulLenFirst, const char * szSecond, HB_SIZE ulLenSecond, PHB_CODEPAGE cdp, HB_BOOL fExact );
extern HB_EXPORT int hb_cdpicmp( const char * szFirst, HB_SIZE ulLenFirst, const char * szSecond, HB_SIZE ulLenSecond, PHB_CODEPAGE cdp, HB_BOOL fExact );
extern HB_EXPORT int hb_cdpcmp( const char * szFirst, HB_SIZE nLenFirst, const char * szSecond, HB_SIZE nLenSecond, PHB_CODEPAGE cdp, HB_BOOL fExact );
extern HB_EXPORT int hb_cdpicmp( const char * szFirst, HB_SIZE nLenFirst, const char * szSecond, HB_SIZE nLenSecond, PHB_CODEPAGE cdp, HB_BOOL fExact );
extern HB_EXPORT int hb_cdpchrcmp( char cFirst, char cSecond, PHB_CODEPAGE cdp );
extern HB_EXPORT char * hb_cdpDup( const char *, PHB_CODEPAGE, PHB_CODEPAGE );
@@ -359,26 +359,26 @@ extern HB_EXPORT HB_SIZE hb_cdpnDupLen( const char *, HB_SIZE, PHB_CODEPAGE
extern HB_EXPORT HB_SIZE hb_cdpnDup2Len( const char *, HB_SIZE, HB_SIZE, PHB_CODEPAGE, PHB_CODEPAGE );
extern HB_EXPORT int hb_cdpTranslateChar( int iChar, HB_BOOL fCtrl, PHB_CODEPAGE cdpIn, PHB_CODEPAGE cdpOut );
extern HB_EXPORT HB_SIZE hb_cdpTransLen( const char * pSrc, HB_SIZE ulSrc, HB_SIZE ulMax, PHB_CODEPAGE cdpIn, PHB_CODEPAGE cdpOut );
extern HB_EXPORT HB_SIZE hb_cdpTransTo( const char * pSrc, HB_SIZE ulSrc, char * pDst, HB_SIZE ulDst, PHB_CODEPAGE cdpIn, PHB_CODEPAGE cdpOut );
extern HB_EXPORT HB_SIZE hb_cdpTransLen( const char * pSrc, HB_SIZE nSrc, HB_SIZE nMax, PHB_CODEPAGE cdpIn, PHB_CODEPAGE cdpOut );
extern HB_EXPORT HB_SIZE hb_cdpTransTo( const char * pSrc, HB_SIZE nSrc, char * pDst, HB_SIZE nDst, PHB_CODEPAGE cdpIn, PHB_CODEPAGE cdpOut );
extern HB_EXPORT HB_WCHAR hb_cdpGetU16( PHB_CODEPAGE cdp, HB_BOOL fCtrl, HB_UCHAR ch );
extern HB_EXPORT HB_UCHAR hb_cdpGetChar( PHB_CODEPAGE cdp, HB_BOOL fCtrl, HB_WCHAR wc );
extern HB_EXPORT HB_BOOL hb_cdpGetFromUTF8( PHB_CODEPAGE cdp, HB_BOOL fCtrl, HB_UCHAR ch, int * n, HB_WCHAR * pwc );
extern HB_EXPORT HB_SIZE hb_cdpUTF8StringLength( const char * pSrc, HB_SIZE ulLen );
extern HB_EXPORT HB_SIZE hb_cdpUTF8StringPeek( const char * pSrc, HB_SIZE ulLen, HB_SIZE ulPos );
extern HB_EXPORT char * hb_cdpUTF8StringSubstr( const char * pSrc, HB_SIZE ulLen, HB_SIZE ulFrom, HB_SIZE ulCount, HB_SIZE * pulDest );
extern HB_EXPORT HB_SIZE hb_cdpUTF8StringLength( const char * pSrc, HB_SIZE nLen );
extern HB_EXPORT HB_SIZE hb_cdpUTF8StringPeek( const char * pSrc, HB_SIZE nLen, HB_SIZE nPos );
extern HB_EXPORT char * hb_cdpUTF8StringSubstr( const char * pSrc, HB_SIZE nLen, HB_SIZE nFrom, HB_SIZE nCount, HB_SIZE * pnDest );
extern HB_EXPORT HB_SIZE hb_cdpUTF8AsStrLen( PHB_CODEPAGE cdp, HB_BOOL fCtrl, const char * pSrc, HB_SIZE ulSrc, HB_SIZE ulMax );
extern HB_EXPORT HB_SIZE hb_cdpUTF8ToStr( PHB_CODEPAGE cdp, HB_BOOL fCtrl, const char * pSrc, HB_SIZE ulSrc, char * pDst, HB_SIZE ulDst );
extern HB_EXPORT HB_SIZE hb_cdpStrAsUTF8Len( PHB_CODEPAGE cdp, HB_BOOL fCtrl, const char * pSrc, HB_SIZE ulSrc, HB_SIZE ulMax );
extern HB_EXPORT HB_SIZE hb_cdpStrToUTF8( PHB_CODEPAGE cdp, HB_BOOL fCtrl, const char * pSrc, HB_SIZE ulSrc, char * pDst, HB_SIZE ulDst );
extern HB_EXPORT HB_SIZE hb_cdpUTF8AsStrLen( PHB_CODEPAGE cdp, HB_BOOL fCtrl, const char * pSrc, HB_SIZE nSrc, HB_SIZE nMax );
extern HB_EXPORT HB_SIZE hb_cdpUTF8ToStr( PHB_CODEPAGE cdp, HB_BOOL fCtrl, const char * pSrc, HB_SIZE nSrc, char * pDst, HB_SIZE nDst );
extern HB_EXPORT HB_SIZE hb_cdpStrAsUTF8Len( PHB_CODEPAGE cdp, HB_BOOL fCtrl, const char * pSrc, HB_SIZE nSrc, HB_SIZE nMax );
extern HB_EXPORT HB_SIZE hb_cdpStrToUTF8( PHB_CODEPAGE cdp, HB_BOOL fCtrl, const char * pSrc, HB_SIZE nSrc, char * pDst, HB_SIZE nDst );
extern HB_EXPORT HB_SIZE hb_cdpU16AsStrLen( PHB_CODEPAGE cdp, HB_BOOL fCtrl, const HB_WCHAR * pSrc, HB_SIZE ulSrc, HB_SIZE ulMax );
extern HB_EXPORT HB_SIZE hb_cdpU16ToStr( PHB_CODEPAGE cdp, HB_BOOL fCtrl, int iEndian, const HB_WCHAR * pSrc, HB_SIZE ulSrc, char * pDst, HB_SIZE ulDst );
extern HB_EXPORT HB_SIZE hb_cdpStrAsU16Len( PHB_CODEPAGE cdp, HB_BOOL fCtrl, const char * pSrc, HB_SIZE ulSrc, HB_SIZE ulMax );
extern HB_EXPORT HB_SIZE hb_cdpStrToU16( PHB_CODEPAGE cdp, HB_BOOL fCtrl, int iEndian, const char * pSrc, HB_SIZE ulSrc, HB_WCHAR * pDst, HB_SIZE ulDst );
extern HB_EXPORT HB_SIZE hb_cdpU16AsStrLen( PHB_CODEPAGE cdp, HB_BOOL fCtrl, const HB_WCHAR * pSrc, HB_SIZE nSrc, HB_SIZE nMax );
extern HB_EXPORT HB_SIZE hb_cdpU16ToStr( PHB_CODEPAGE cdp, HB_BOOL fCtrl, int iEndian, const HB_WCHAR * pSrc, HB_SIZE nSrc, char * pDst, HB_SIZE nDst );
extern HB_EXPORT HB_SIZE hb_cdpStrAsU16Len( PHB_CODEPAGE cdp, HB_BOOL fCtrl, const char * pSrc, HB_SIZE nSrc, HB_SIZE nMax );
extern HB_EXPORT HB_SIZE hb_cdpStrToU16( PHB_CODEPAGE cdp, HB_BOOL fCtrl, int iEndian, const char * pSrc, HB_SIZE nSrc, HB_WCHAR * pDst, HB_SIZE nDst );
extern HB_EXPORT int hb_cdpUTF8CharSize( HB_WCHAR wc );
extern HB_EXPORT int hb_cdpU16CharToUTF8( char * szUTF8, HB_WCHAR wc );

22
harbour/include/hbapifs.h
View File

@@ -164,7 +164,7 @@ extern HB_EXPORT HB_FHANDLE hb_fsCreateTemp ( const char * pszDir, const char *
extern HB_EXPORT HB_FHANDLE hb_fsCreateTempEx( char * pszName, const char * pszDir, const char * pszPrefix, const char * pszExt, HB_FATTR ulAttr ); /* create a temporary file from components */
extern HB_EXPORT HB_ERRCODE hb_fsTempDir ( char * pszDir ); /* full buffer with system temp directory (or empty on error) */
extern HB_EXPORT const char * hb_fsCurDir ( int iDrive ); /* retrieve a static pointer containing current directory for specified drive */
extern HB_EXPORT HB_ERRCODE hb_fsCurDirBuff ( int iDrive, char * pbyBuffer, HB_SIZE ulLen ); /* copy current directory for given drive into a buffer */
extern HB_EXPORT HB_ERRCODE hb_fsCurDirBuff ( int iDrive, char * pbyBuffer, HB_SIZE nLen ); /* copy current directory for given drive into a buffer */
extern HB_EXPORT void hb_fsBaseDirBuff ( char * pbyBuffer ); /* retrieve the base dir of the executable */
extern HB_EXPORT int hb_fsCurDrv ( void ); /* retrieve current drive number */
extern HB_EXPORT HB_BOOL hb_fsDelete ( const char * pszFileName ); /* delete a file */
@@ -182,7 +182,7 @@ extern HB_EXPORT HB_ERRCODE hb_fsIsDrv ( int iDrive ); /* determine if a d
extern HB_EXPORT HB_BOOL hb_fsIsDevice ( HB_FHANDLE hFileHandle ); /* determine if a file is attached to a device (console?) */
extern HB_EXPORT HB_BOOL hb_fsLock ( HB_FHANDLE hFileHandle, HB_ULONG ulStart, HB_ULONG ulLength, HB_USHORT uiMode ); /* request a lock on a portion of a file */
extern HB_EXPORT HB_BOOL hb_fsLockLarge ( HB_FHANDLE hFileHandle, HB_FOFFSET ulStart,
HB_FOFFSET ulLength, HB_USHORT uiMode ); /* request a lock on a portion of a file using 64bit API */
HB_FOFFSET nLength, HB_USHORT uiMode ); /* request a lock on a portion of a file using 64bit API */
extern HB_EXPORT HB_BOOL hb_fsMkDir ( const char * pszDirName ); /* create a directory */
extern HB_EXPORT HB_FHANDLE hb_fsOpen ( const char * pszFileName, HB_USHORT uiFlags ); /* open a file */
extern HB_EXPORT HB_USHORT hb_fsRead ( HB_FHANDLE hFileHandle, void * pBuff, HB_USHORT uiCount ); /* read contents of a file into a buffer (<=64K) */
@@ -299,9 +299,9 @@ extern HB_EXPORT HB_FHANDLE hb_fsProcessOpen( const char * pszFilename,
HB_FHANDLE * phStderr,
HB_BOOL fDetach, HB_ULONG * pulPID );
extern HB_EXPORT int hb_fsProcessRun( const char * pszFilename,
const char * pStdInBuf, HB_SIZE ulStdInLen,
char ** pStdOutPtr, HB_SIZE * pulStdOut,
char ** pStdErrPtr, HB_SIZE * pulStdErr,
const char * pStdInBuf, HB_SIZE nStdInLen,
char ** pStdOutPtr, HB_SIZE * pnStdOut,
char ** pStdErrPtr, HB_SIZE * pnStdErr,
HB_BOOL fDetach );
extern HB_EXPORT int hb_fsProcessValue( HB_FHANDLE hProcess, HB_BOOL fWait );
extern HB_EXPORT HB_BOOL hb_fsProcessClose( HB_FHANDLE hProcess, HB_BOOL fGentle );
@@ -333,9 +333,9 @@ extern HB_EXPORT const char * hb_fsNameConv( const char * szFileName, char ** ps
HB_USHORT uiExFlags, const char * pPaths,
PHB_ITEM pError );
void (* Close ) ( PHB_FILE pFile );
HB_BOOL (* Lock ) ( PHB_FILE, HB_FOFFSET ulStart, HB_FOFFSET ulLen, int iType );
HB_SIZE (* ReadAt ) ( PHB_FILE pFile, void * buffer, HB_SIZE ulSize, HB_FOFFSET llOffset );
HB_SIZE (* WriteAt ) ( PHB_FILE pFile, const void * buffer, HB_SIZE ulSize, HB_FOFFSET llOffset );
HB_BOOL (* Lock ) ( PHB_FILE, HB_FOFFSET ulStart, HB_FOFFSET nLen, int iType );
HB_SIZE (* ReadAt ) ( PHB_FILE pFile, void * buffer, HB_SIZE nSize, HB_FOFFSET llOffset );
HB_SIZE (* WriteAt ) ( PHB_FILE pFile, const void * buffer, HB_SIZE nSize, HB_FOFFSET llOffset );
HB_BOOL (* TruncAt ) ( PHB_FILE pFile, HB_FOFFSET llOffset );
HB_FOFFSET (* Size ) ( PHB_FILE pFile );
void (* Flush ) ( PHB_FILE pFile, HB_BOOL fDirty );
@@ -363,9 +363,9 @@ extern HB_EXPORT PHB_FILE hb_fileCreateTempEx( char * pszName,
const char * pszExt,
HB_FATTR ulAttr );
extern HB_EXPORT void hb_fileClose( PHB_FILE pFile );
extern HB_EXPORT HB_BOOL hb_fileLock( PHB_FILE pFile, HB_FOFFSET ulStart, HB_FOFFSET ulLen, int iType );
extern HB_EXPORT HB_SIZE hb_fileReadAt( PHB_FILE pFile, void * buffer, HB_SIZE ulSize, HB_FOFFSET llOffset );
extern HB_EXPORT HB_SIZE hb_fileWriteAt( PHB_FILE pFile, const void * buffer, HB_SIZE ulSize, HB_FOFFSET llOffset );
extern HB_EXPORT HB_BOOL hb_fileLock( PHB_FILE pFile, HB_FOFFSET ulStart, HB_FOFFSET nLen, int iType );
extern HB_EXPORT HB_SIZE hb_fileReadAt( PHB_FILE pFile, void * buffer, HB_SIZE nSize, HB_FOFFSET llOffset );
extern HB_EXPORT HB_SIZE hb_fileWriteAt( PHB_FILE pFile, const void * buffer, HB_SIZE nSize, HB_FOFFSET llOffset );
extern HB_EXPORT HB_BOOL hb_fileTruncAt( PHB_FILE pFile, HB_FOFFSET llOffset );
extern HB_EXPORT HB_FOFFSET hb_fileSize( PHB_FILE pFile );
extern HB_EXPORT void hb_fileFlush( PHB_FILE pFile, HB_BOOL fDirty );

18
harbour/include/hbapigt.h
View File

@@ -190,8 +190,8 @@ extern HB_EXPORT HB_ERRCODE hb_gtPreExt( void );
extern HB_EXPORT HB_ERRCODE hb_gtSuspend( void ); /* prepare the reminal for shell output */
extern HB_EXPORT HB_ERRCODE hb_gtResume( void ); /* resume the terminal after the shell output */
extern HB_EXPORT int hb_gtReadKey( int iEventMask );
extern HB_EXPORT HB_ERRCODE hb_gtRectSize( int iTop, int iLeft, int iBottom, int iRight, HB_SIZE * pulBuffSize );
extern HB_EXPORT HB_ERRCODE hb_gtRepChar( int iRow, int iCol, HB_USHORT usChar, HB_SIZE ulCount );
extern HB_EXPORT HB_ERRCODE hb_gtRectSize( int iTop, int iLeft, int iBottom, int iRight, HB_SIZE * pnBuffSize );
extern HB_EXPORT HB_ERRCODE hb_gtRepChar( int iRow, int iCol, HB_USHORT usChar, HB_SIZE nCount );
extern HB_EXPORT HB_ERRCODE hb_gtSave( int iTop, int iLeft, int iBottom, int iRight, void * pScrBuff );
extern HB_EXPORT HB_ERRCODE hb_gtRest( int iTop, int iLeft, int iBottom, int iRight, const void * pScrBuff );
extern HB_EXPORT HB_ERRCODE hb_gtGetChar( int iRow, int iCol, int * piColor, HB_BYTE * pbAttr, HB_USHORT * pusChar );
@@ -209,13 +209,13 @@ extern HB_EXPORT HB_ERRCODE hb_gtSetMode( int iRows, int iCols );
extern HB_EXPORT HB_ERRCODE hb_gtSetPos( int iRow, int iCol );
extern HB_EXPORT HB_ERRCODE hb_gtSetSnowFlag( HB_BOOL bNoSnow );
extern HB_EXPORT HB_ERRCODE hb_gtTone( double dFrequency, double dDuration );
extern HB_EXPORT HB_ERRCODE hb_gtWrite( const char * szStr, HB_SIZE ulLen );
extern HB_EXPORT HB_ERRCODE hb_gtWriteAt( int iRow, int iCol, const char * szStr, HB_SIZE ulLen );
extern HB_EXPORT HB_ERRCODE hb_gtWriteCon( const char * szStr, HB_SIZE ulLen );
extern HB_EXPORT HB_ERRCODE hb_gtPutText( int iRow, int iCol, const char * szStr, HB_SIZE ulLength, int iColor );
extern HB_EXPORT HB_ERRCODE hb_gtWrite( const char * szStr, HB_SIZE nLen );
extern HB_EXPORT HB_ERRCODE hb_gtWriteAt( int iRow, int iCol, const char * szStr, HB_SIZE nLen );
extern HB_EXPORT HB_ERRCODE hb_gtWriteCon( const char * szStr, HB_SIZE nLen );
extern HB_EXPORT HB_ERRCODE hb_gtPutText( int iRow, int iCol, const char * szStr, HB_SIZE nLength, int iColor );
extern HB_EXPORT const char * hb_gtVersion( int iType );
extern HB_EXPORT HB_ERRCODE hb_gtOutStd( const char * szStr, HB_SIZE ulLen );
extern HB_EXPORT HB_ERRCODE hb_gtOutErr( const char * szStr, HB_SIZE ulLen );
extern HB_EXPORT HB_ERRCODE hb_gtOutStd( const char * szStr, HB_SIZE nLen );
extern HB_EXPORT HB_ERRCODE hb_gtOutErr( const char * szStr, HB_SIZE nLen );
extern HB_EXPORT HB_ERRCODE hb_gtSetDispCP( const char * pszTermCDP, const char * pszHostCDP, HB_BOOL fBox );
extern HB_EXPORT HB_ERRCODE hb_gtSetKeyCP( const char * pszTermCDP, const char * pszHostCDP );
extern HB_EXPORT HB_ERRCODE hb_gtInfo( int iType, PHB_GT_INFO pInfo );
@@ -310,7 +310,7 @@ extern HB_EXPORT int hb_inkeyNext( int iEvenMask ); /* Return the next k
extern HB_EXPORT void hb_inkeyPoll( void ); /* Poll the console keyboard to stuff the Harbour buffer */
extern HB_EXPORT void hb_inkeyReset( void ); /* Reset the Harbour keyboard buffer */
extern HB_EXPORT void hb_inkeySetCancelKeys( int CancelKey, int CancelKeyEx ); /* Set keycodes for Cancel key (usually K_ALT_C) */
extern HB_EXPORT void hb_inkeySetText( const char * szText, HB_SIZE ulLen ); /* Set text into inkey buffer */
extern HB_EXPORT void hb_inkeySetText( const char * szText, HB_SIZE nLen ); /* Set text into inkey buffer */
extern HB_EXPORT int hb_inkeySetLast( int iKey ); /* Set new LASTKEY() value, return previous one */
extern HB_EXPORT void hb_inkeyExit( void ); /* reset inkey pool to default state and free any allocated resources */

26
harbour/include/hbapiitm.h
View File

@@ -79,10 +79,10 @@ extern HB_EXPORT HB_BOOL hb_execFromArray ( PHB_ITEM pParam );
extern HB_EXPORT PHB_ITEM hb_itemDo ( PHB_ITEM pItem, HB_ULONG ulPCount, ... );
extern HB_EXPORT PHB_ITEM hb_itemDoC ( const char * szFunc, HB_ULONG ulPCount, ... );
extern HB_EXPORT PHB_ITEM hb_itemArrayGet ( PHB_ITEM pArray, HB_SIZE ulIndex );
extern HB_EXPORT PHB_ITEM hb_itemArrayNew ( HB_SIZE ulLen );
extern HB_EXPORT PHB_ITEM hb_itemArrayPut ( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem );
extern HB_EXPORT HB_SIZE hb_itemCopyC ( PHB_ITEM pItem, char * szBuffer, HB_SIZE ulLen );
extern HB_EXPORT PHB_ITEM hb_itemArrayGet ( PHB_ITEM pArray, HB_SIZE nIndex );
extern HB_EXPORT PHB_ITEM hb_itemArrayNew ( HB_SIZE nLen );
extern HB_EXPORT PHB_ITEM hb_itemArrayPut ( PHB_ITEM pArray, HB_SIZE nIndex, PHB_ITEM pItem );
extern HB_EXPORT HB_SIZE hb_itemCopyC ( PHB_ITEM pItem, char * szBuffer, HB_SIZE nLen );
extern HB_EXPORT HB_BOOL hb_itemFreeC ( char * szText );
extern HB_EXPORT char * hb_itemGetC ( PHB_ITEM pItem );
extern HB_EXPORT const char * hb_itemGetCPtr ( PHB_ITEM pItem );
@@ -108,11 +108,11 @@ extern HB_EXPORT void hb_itemInit ( PHB_ITEM pItem );
extern HB_EXPORT HB_USHORT hb_itemPCount ( void );
extern HB_EXPORT PHB_ITEM hb_itemParam ( HB_USHORT uiParam );
extern HB_EXPORT PHB_ITEM hb_itemPutC ( PHB_ITEM pItem, const char * szText );
extern HB_EXPORT PHB_ITEM hb_itemPutCL ( PHB_ITEM pItem, const char * szText, HB_SIZE ulLen );
extern HB_EXPORT PHB_ITEM hb_itemPutCL ( PHB_ITEM pItem, const char * szText, HB_SIZE nLen );
extern HB_EXPORT PHB_ITEM hb_itemPutCConst ( PHB_ITEM pItem, const char * szText );
extern HB_EXPORT PHB_ITEM hb_itemPutCLConst( PHB_ITEM pItem, const char * szText, HB_SIZE ulLen );
extern HB_EXPORT PHB_ITEM hb_itemPutCLConst( PHB_ITEM pItem, const char * szText, HB_SIZE nLen );
extern HB_EXPORT PHB_ITEM hb_itemPutCPtr ( PHB_ITEM pItem, char * szText );
extern HB_EXPORT PHB_ITEM hb_itemPutCLPtr ( PHB_ITEM pItem, char * szText, HB_SIZE ulLen );
extern HB_EXPORT PHB_ITEM hb_itemPutCLPtr ( PHB_ITEM pItem, char * szText, HB_SIZE nLen );
extern HB_EXPORT void hb_itemSetCMemo ( PHB_ITEM pItem );
extern HB_EXPORT PHB_ITEM hb_itemPutD ( PHB_ITEM pItem, int iYear, int iMonth, int iDay );
extern HB_EXPORT PHB_ITEM hb_itemPutDS ( PHB_ITEM pItem, const char * szDate );
@@ -170,19 +170,19 @@ extern HB_EXPORT PHB_ITEM hb_itemUnRefRefer( PHB_ITEM pItem ); /* de-referen
extern HB_EXPORT PHB_ITEM hb_itemUnRefWrite( PHB_ITEM pItem, PHB_ITEM pSource ); /* de-references passed variable for writing */
extern HB_EXPORT PHB_ITEM hb_itemUnShare ( PHB_ITEM pItem ); /* un-share given string item */
extern HB_EXPORT PHB_ITEM hb_itemUnShareString( PHB_ITEM pItem ); /* un-share given string item - the pItem have to be valid unrefed string item */
extern HB_EXPORT PHB_ITEM hb_itemReSizeString( PHB_ITEM pItem, HB_SIZE ulSize ); /* Resize string buffer of given string item - the pItem have to be valid unrefed string item */
extern HB_EXPORT HB_BOOL hb_itemGetWriteCL( PHB_ITEM pItem, char ** pszValue, HB_SIZE * pulLen );
extern HB_EXPORT PHB_ITEM hb_itemReSizeString( PHB_ITEM pItem, HB_SIZE nSize ); /* Resize string buffer of given string item - the pItem have to be valid unrefed string item */
extern HB_EXPORT HB_BOOL hb_itemGetWriteCL( PHB_ITEM pItem, char ** pszValue, HB_SIZE * pnLen );
extern HB_EXPORT PHB_ITEM hb_itemClone ( PHB_ITEM pItem ); /* clone the given item */
extern HB_EXPORT PHB_ITEM hb_itemCloneTo ( PHB_ITEM pDest, PHB_ITEM pSource ); /* clone the given item */
extern HB_EXPORT char * hb_itemStr ( PHB_ITEM pNumber, PHB_ITEM pWidth, PHB_ITEM pDec ); /* convert a number to a string */
extern HB_EXPORT char * hb_itemString ( PHB_ITEM pItem, HB_SIZE * ulLen, HB_BOOL * bFreeReq ); /* Convert any scalar to a string */
extern HB_EXPORT char * hb_itemString ( PHB_ITEM pItem, HB_SIZE * nLen, HB_BOOL * bFreeReq ); /* Convert any scalar to a string */
extern HB_EXPORT HB_BOOL hb_itemStrBuf ( char *szResult, PHB_ITEM pNumber, int iSize, int iDec ); /* convert a number to a string */
extern HB_EXPORT PHB_ITEM hb_itemValToStr ( PHB_ITEM pItem ); /* Convert any scalar to a string */
extern HB_EXPORT char * hb_itemPadConv ( PHB_ITEM pItem, HB_SIZE * pulSize, HB_BOOL * bFreeReq );
extern HB_EXPORT char * hb_itemPadConv ( PHB_ITEM pItem, HB_SIZE * pnSize, HB_BOOL * bFreeReq );
extern HB_EXPORT void hb_itemSwap ( PHB_ITEM pItem1, PHB_ITEM pItem2 );
extern HB_EXPORT char * hb_itemSerialize( PHB_ITEM pItem, HB_BOOL fNumSize, HB_SIZE * pulSize );
extern HB_EXPORT PHB_ITEM hb_itemDeserialize( const char ** pBufferPtr, HB_SIZE * pulSize );
extern HB_EXPORT char * hb_itemSerialize( PHB_ITEM pItem, HB_BOOL fNumSize, HB_SIZE * pnSize );
extern HB_EXPORT PHB_ITEM hb_itemDeserialize( const char ** pBufferPtr, HB_SIZE * pnSize );
#if defined( _HB_API_INTERNAL_ )

28
harbour/include/hbcomp.h
View File

@@ -71,7 +71,7 @@ HB_EXTERN_BEGIN
/* definitions for hb_compPCodeEval() support */
typedef void * HB_VOID_PTR;
#define HB_PCODE_FUNC( func, type ) HB_SIZE func( PFUNCTION pFunc, HB_SIZE lPCodePos, type cargo )
#define HB_PCODE_FUNC( func, type ) HB_SIZE func( PFUNCTION pFunc, HB_SIZE nPCodePos, type cargo )
typedef HB_PCODE_FUNC( HB_PCODE_FUNC_, HB_VOID_PTR );
typedef HB_PCODE_FUNC_ * HB_PCODE_FUNC_PTR;
@@ -179,11 +179,11 @@ extern void hb_compLoopKill( PFUNCTION );
extern void hb_compGenError( HB_COMP_DECL, const char * szErrors[], char cPrefix, int iError, const char * szError1, const char * szError2 ); /* generic parsing error management function */
extern void hb_compGenWarning( HB_COMP_DECL, const char * szWarnings[], char cPrefix, int iWarning, const char * szWarning1, const char * szWarning2); /* generic parsing warning management function */
extern HB_SIZE hb_compGenJump( HB_ISIZ lOffset, HB_COMP_DECL ); /* generates the pcode to jump to a specific offset */
extern HB_SIZE hb_compGenJumpFalse( HB_ISIZ lOffset, HB_COMP_DECL ); /* generates the pcode to jump if false */
extern HB_SIZE hb_compGenJumpTrue( HB_ISIZ lOffset, HB_COMP_DECL ); /* generates the pcode to jump if true */
extern void hb_compGenJumpHere( HB_SIZE ulOffset, HB_COMP_DECL ); /* returns the pcode pos where to set a jump offset */
extern void hb_compGenJumpThere( HB_SIZE ulFrom, HB_SIZE ulTo, HB_COMP_DECL ); /* sets a jump offset */
extern HB_SIZE hb_compGenJump( HB_ISIZ nOffset, HB_COMP_DECL ); /* generates the pcode to jump to a specific offset */
extern HB_SIZE hb_compGenJumpFalse( HB_ISIZ nOffset, HB_COMP_DECL ); /* generates the pcode to jump if false */
extern HB_SIZE hb_compGenJumpTrue( HB_ISIZ nOffset, HB_COMP_DECL ); /* generates the pcode to jump if true */
extern void hb_compGenJumpHere( HB_SIZE nOffset, HB_COMP_DECL ); /* returns the pcode pos where to set a jump offset */
extern void hb_compGenJumpThere( HB_SIZE nFrom, HB_SIZE nTo, HB_COMP_DECL ); /* sets a jump offset */
extern void hb_compGenModuleName( HB_COMP_DECL, const char * szFunName ); /* generates the pcode with the currently compiled module and function name */
extern void hb_compLinePush( HB_COMP_DECL ); /* generates the pcode with the currently compiled source code line */
@@ -208,7 +208,7 @@ extern void hb_compGenPushLong( HB_MAXINT lNumber, HB_COMP_DECL );
extern void hb_compGenPushDate( long lDate, HB_COMP_DECL ); /* Pushes a date constant on the virtual machine stack */
extern void hb_compGenPushTimeStamp( long lDate, long lTime, HB_COMP_DECL ); /* Pushes a timestamp constant on the virtual machine stack */
extern void hb_compGenPushNil( HB_COMP_DECL ); /* Pushes nil on the virtual machine stack */
extern void hb_compGenPushString( const char * szText, HB_SIZE ulLen, HB_COMP_DECL ); /* Pushes a string on the virtual machine stack */
extern void hb_compGenPushString( const char * szText, HB_SIZE nLen, HB_COMP_DECL ); /* Pushes a string on the virtual machine stack */
extern void hb_compGenPushSymbol( const char * szSymbolName, HB_BOOL bFunction, HB_COMP_DECL ); /* Pushes a symbol on to the Virtual machine stack */
extern void hb_compGenPushAliasedVar( const char *, HB_BOOL, const char *, HB_MAXINT, HB_COMP_DECL );
extern void hb_compGenPopAliasedVar( const char *, HB_BOOL, const char *, HB_MAXINT, HB_COMP_DECL );
@@ -216,13 +216,13 @@ extern void hb_compGenPCode1( HB_BYTE, HB_COMP_DECL ); /* generates 1 byte of pc
extern void hb_compGenPCode2( HB_BYTE, HB_BYTE, HB_COMP_DECL ); /* generates 2 bytes of pcode + flag for optional StrongType(). */
extern void hb_compGenPCode3( HB_BYTE, HB_BYTE, HB_BYTE, HB_COMP_DECL ); /* generates 3 bytes of pcode + flag for optional StrongType() */
extern void hb_compGenPCode4( HB_BYTE, HB_BYTE, HB_BYTE, HB_BYTE, HB_COMP_DECL ); /* generates 4 bytes of pcode + flag for optional StrongType() */
extern void hb_compGenPCodeN( const HB_BYTE * pBuffer, HB_SIZE ulSize, HB_COMP_DECL ); /* copy bytes to a pcode buffer + flag for optional StrongType() */
extern void hb_compGenPCodeN( const HB_BYTE * pBuffer, HB_SIZE nSize, HB_COMP_DECL ); /* copy bytes to a pcode buffer + flag for optional StrongType() */
extern HB_SIZE hb_compSequenceBegin( HB_COMP_DECL );
extern HB_SIZE hb_compSequenceEnd( HB_COMP_DECL );
extern HB_SIZE hb_compSequenceAlways( HB_COMP_DECL );
extern void hb_compSequenceFinish( HB_COMP_DECL, HB_SIZE ulStartPos, HB_SIZE ulEndPos,
HB_SIZE ulAlways, HB_BOOL fUsualStmts, HB_BOOL fRecover,
extern void hb_compSequenceFinish( HB_COMP_DECL, HB_SIZE nStartPos, HB_SIZE nEndPos,
HB_SIZE nAlways, HB_BOOL fUsualStmts, HB_BOOL fRecover,
HB_BOOL fCanMove );
/* support for FIELD declaration */
@@ -289,7 +289,7 @@ extern void hb_compErrorVParams( HB_COMP_DECL, const char * szFuncOrBlock
extern HB_EXPR_PTR hb_compErrorStatic( HB_COMP_DECL, const char *, HB_EXPR_PTR );
extern void hb_compErrorCodeblock( HB_COMP_DECL, const char * szBlock );
extern HB_BOOL hb_compIsValidMacroText( HB_COMP_DECL, const char * szText, HB_SIZE ulLen );
extern HB_BOOL hb_compIsValidMacroText( HB_COMP_DECL, const char * szText, HB_SIZE nLen );
/* Codeblocks */
extern void hb_compCodeBlockStart( HB_COMP_DECL, HB_BOOL bLateEval ); /* starts a codeblock creation */
@@ -313,8 +313,8 @@ extern void hb_compPrintLogo( HB_COMP_DECL );
extern void hb_compPrintModes( HB_COMP_DECL );
/* Misc functions defined in harbour.c */
extern void hb_compNOOPfill( PFUNCTION pFunc, HB_SIZE ulFrom, HB_ISIZ iCount, HB_BOOL fPop, HB_BOOL fCheck );
extern HB_BOOL hb_compHasJump( PFUNCTION pFunc, HB_SIZE ulPos );
extern void hb_compNOOPfill( PFUNCTION pFunc, HB_SIZE nFrom, HB_ISIZ nCount, HB_BOOL fPop, HB_BOOL fCheck );
extern HB_BOOL hb_compHasJump( PFUNCTION pFunc, HB_SIZE nPos );
/* Misc functions defined in hbfix.c */
extern void hb_compFixFuncPCode( HB_COMP_DECL, PFUNCTION pFunc );
@@ -337,7 +337,7 @@ extern void hb_compGenCObj( HB_COMP_DECL, PHB_FNAME ); /* generates platfo
extern void hb_compGenBufPortObj( HB_COMP_DECL, HB_BYTE ** pBufPtr, HB_SIZE * pulSize ); /* generates the portable objects to memory buffer */
extern void hb_compGenCRealCode( HB_COMP_DECL, PFUNCTION pFunc, FILE * yyc );
extern void hb_compGenCString( FILE * yyc, const HB_BYTE * pText, HB_SIZE ulLen );
extern void hb_compGenCString( FILE * yyc, const HB_BYTE * pText, HB_SIZE nLen );
/* hbident.c */
extern const char * hb_compIdentifierNew( HB_COMP_DECL, const char * szName, int iType ); /* create the reusable identifier */

8
harbour/include/hbdefs.h
View File

@@ -1573,10 +1573,10 @@ typedef HB_U32 HB_FATTR;
HB_EXTERN_BEGIN
extern HB_EXPORT wchar_t * hb_mbtowc( const char * srcA );
extern HB_EXPORT char * hb_wctomb( const wchar_t * srcW );
extern HB_EXPORT wchar_t * hb_mbntowc( const char * srcA, HB_SIZE ulLen );
extern HB_EXPORT char * hb_wcntomb( const wchar_t * srcW, HB_SIZE ulLen );
extern HB_EXPORT void hb_wcntombcpy( char * dstA, const wchar_t * srcW, HB_SIZE ulLen );
extern HB_EXPORT void hb_mbntowccpy( wchar_t * dstW, const char * srcA, HB_SIZE ulLen );
extern HB_EXPORT wchar_t * hb_mbntowc( const char * srcA, HB_SIZE nLen );
extern HB_EXPORT char * hb_wcntomb( const wchar_t * srcW, HB_SIZE nLen );
extern HB_EXPORT void hb_wcntombcpy( char * dstA, const wchar_t * srcW, HB_SIZE nLen );
extern HB_EXPORT void hb_mbntowccpy( wchar_t * dstW, const char * srcA, HB_SIZE nLen );
HB_EXTERN_END
#endif

6
harbour/include/hbexprop.h
View File

@@ -82,10 +82,10 @@ extern HB_EXPR_PTR hb_compExprNewDouble( double, HB_BYTE, HB_BYTE, HB_COMP_DECL
extern HB_EXPR_PTR hb_compExprNewLong( HB_MAXINT lValue, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewDate( long lDate, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewTimeStamp( long lDate, long lTime, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewString( const char * szValue, HB_SIZE ulLen, HB_BOOL fDealloc, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewString( const char * szValue, HB_SIZE nLen, HB_BOOL fDealloc, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewLogical( int iValue, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewSelf( HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewCodeBlock( char * string, HB_SIZE ulLen, int iFlags, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewCodeBlock( char * string, HB_SIZE nLen, int iFlags, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewVar( const char * szName, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewAliasVar( HB_EXPR_PTR, HB_EXPR_PTR, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewAliasExpr( HB_EXPR_PTR, HB_EXPR_PTR, HB_COMP_DECL );
@@ -141,7 +141,7 @@ extern HB_EXPR_PTR hb_compExprAddListExpr( HB_EXPR_PTR, HB_EXPR_PTR );
extern HB_EXPR_PTR hb_compExprCBVarAdd( HB_EXPR_PTR, const char * szVarName, HB_BYTE bType, HB_COMP_DECL );
extern void hb_compExprCBVarDel( HB_CBVAR_PTR );
extern HB_EXPR_PTR hb_compExprAddCodeblockExpr( HB_EXPR_PTR, HB_EXPR_PTR );
extern HB_EXPR_PTR hb_compExprSetCodeblockBody( HB_EXPR_PTR pExpr, HB_BYTE * pCode, HB_SIZE ulLen );
extern HB_EXPR_PTR hb_compExprSetCodeblockBody( HB_EXPR_PTR pExpr, HB_BYTE * pCode, HB_SIZE nLen );
extern HB_EXPR_PTR hb_compExprNewIIF( HB_EXPR_PTR );
extern HB_EXPR_PTR hb_compExprMacroAsAlias( HB_EXPR_PTR );
extern HB_EXPR_PTR hb_compExprAssign( HB_EXPR_PTR, HB_EXPR_PTR, HB_COMP_DECL );

6
harbour/include/hbgtcore.h
View File

@@ -204,7 +204,7 @@ typedef struct
int (* InkeyLast) ( HB_GT_PTR, int iEventMask );
int (* InkeyNext) ( HB_GT_PTR, int iEventMask );
void (* InkeyPoll) ( HB_GT_PTR );
void (* InkeySetText) ( HB_GT_PTR, const char * szText, HB_SIZE ulLen );
void (* InkeySetText) ( HB_GT_PTR, const char * szText, HB_SIZE nLen );
int (* InkeySetLast) ( HB_GT_PTR, int iKey );
void (* InkeyReset) ( HB_GT_PTR );
void (* InkeyExit) ( HB_GT_PTR );
@@ -597,8 +597,8 @@ extern HB_EXPORT PHB_GT hb_gtLoad( const char * szGtName, PHB_GT pGT, PHB_GT_FU
/* low level GT functions common to different GTs supported by RTL */
extern int hb_gt_chrmapinit( int * piTransTbl, const char * pszTerm, HB_BOOL fSetACSC );
extern HB_BOOL hb_gt_setClipboard( const char * szClipData, HB_SIZE ulLen );
extern HB_BOOL hb_gt_getClipboard( char ** pszClipData, HB_SIZE * pulLen );
extern HB_BOOL hb_gt_setClipboard( const char * szClipData, HB_SIZE nLen );
extern HB_BOOL hb_gt_getClipboard( char ** pszClipData, HB_SIZE * pnLen );
#if defined( HB_OS_WIN )
extern HB_BOOL hb_gt_winapi_setClipboard( HB_UINT uFormat, PHB_ITEM pItem );
extern HB_BOOL hb_gt_winapi_getClipboard( HB_UINT uFormat, PHB_ITEM pItem );

4
harbour/include/hbhash.h
View File

@@ -83,7 +83,7 @@ typedef struct HB_HASH_TABLE_
} HB_HASH_TABLE, * HB_HASH_TABLE_PTR;
extern HB_HASH_TABLE_PTR hb_hashTableCreate( HB_SIZE ulSize,
extern HB_HASH_TABLE_PTR hb_hashTableCreate( HB_SIZE nSize,
HB_HASH_FUNC_PTR pHashFunc,
HB_HASH_FUNC_PTR pDelete,
HB_HASH_FUNC_PTR pComp );
@@ -91,7 +91,7 @@ extern void hb_hashTableKill( HB_HASH_TABLE_PTR pTable ); /* release all items a
extern HB_BOOL hb_hashTableAdd( HB_HASH_TABLE_PTR pTable, const void * pKey, const void * pValue ); /* add a new item into the table */
extern HB_BOOL hb_hashTableDel( HB_HASH_TABLE_PTR pTable, const void * pKey ); /* delete an item from the table */
extern const void * hb_hashTableFind( HB_HASH_TABLE_PTR pTable, const void * pKey ); /* return the pointer to item's value or NULL if not found */
extern HB_HASH_TABLE_PTR hb_hashTableResize( HB_HASH_TABLE_PTR pTable, HB_SIZE ulNewSize ); /* resize the hash table */
extern HB_HASH_TABLE_PTR hb_hashTableResize( HB_HASH_TABLE_PTR pTable, HB_SIZE nNewSize ); /* resize the hash table */
extern HB_SIZE hb_hashTableSize( HB_HASH_TABLE_PTR pTable ); /* return the hash table size */
HB_EXTERN_END

20
harbour/include/hbmacro.h
View File

@@ -121,16 +121,16 @@ extern void hb_macroGenPCode1( HB_BYTE byte, HB_COMP_DECL );
extern void hb_macroGenPCode2( HB_BYTE byte1, HB_BYTE byte2, HB_COMP_DECL );
extern void hb_macroGenPCode3( HB_BYTE byte1, HB_BYTE byte2, HB_BYTE byte3, HB_COMP_DECL );
extern void hb_macroGenPCode4( HB_BYTE byte1, HB_BYTE byte2, HB_BYTE byte3, HB_BYTE byte4, HB_COMP_DECL );
extern void hb_macroGenPCodeN( HB_BYTE * pBuffer, HB_SIZE ulSize, HB_COMP_DECL );
extern void hb_macroGenPCodeN( HB_BYTE * pBuffer, HB_SIZE nSize, HB_COMP_DECL );
extern HB_SIZE hb_macroGenJump( HB_ISIZ lOffset, HB_COMP_DECL );
extern HB_SIZE hb_macroGenJumpFalse( HB_ISIZ lOffset, HB_COMP_DECL );
extern void hb_macroGenJumpThere( HB_SIZE ulFrom, HB_SIZE ulTo, HB_COMP_DECL );
extern void hb_macroGenJumpHere( HB_SIZE ulOffset, HB_COMP_DECL );
extern HB_SIZE hb_macroGenJumpTrue( HB_ISIZ lOffset, HB_COMP_DECL );
extern HB_SIZE hb_macroGenJump( HB_ISIZ nOffset, HB_COMP_DECL );
extern HB_SIZE hb_macroGenJumpFalse( HB_ISIZ nOffset, HB_COMP_DECL );
extern void hb_macroGenJumpThere( HB_SIZE nFrom, HB_SIZE nTo, HB_COMP_DECL );
extern void hb_macroGenJumpHere( HB_SIZE nOffset, HB_COMP_DECL );
extern HB_SIZE hb_macroGenJumpTrue( HB_ISIZ nOffset, HB_COMP_DECL );
extern void hb_macroGenPushSymbol( const char * szSymbolName, HB_BOOL bFunction, HB_COMP_DECL );
extern void hb_macroGenPushLong( HB_MAXINT lNumber, HB_COMP_DECL );
extern void hb_macroGenPushLong( HB_MAXINT nNumber, HB_COMP_DECL );
extern void hb_macroGenPushDate( long lDate, HB_COMP_DECL );
extern void hb_macroGenPushTimeStamp( long lDate, long lTime, HB_COMP_DECL );
extern void hb_macroGenMessage( const char * szMsgName, HB_BOOL bIsObject, HB_COMP_DECL );
@@ -147,19 +147,19 @@ extern void hb_macroGenPushMemvarRef( const char * szVarName, HB_COMP_DECL );
extern void hb_macroGenPushAliasedVar( const char * szVarName,
HB_BOOL bPushAliasValue,
const char * szAlias,
HB_MAXINT lWorkarea, HB_COMP_DECL );
HB_MAXINT nWorkarea, HB_COMP_DECL );
extern void hb_macroGenPushLogical( int iTrueFalse, HB_COMP_DECL );
extern void hb_macroGenPushDouble( double dNumber, HB_BYTE bWidth, HB_BYTE bDec, HB_COMP_DECL );
extern void hb_macroGenPushFunCall( const char * szFunName, int iFlags, HB_COMP_DECL );
extern void hb_macroGenPushFunSym( const char * szFunName, int iFlags, HB_COMP_DECL );
extern void hb_macroGenPushFunRef( const char * szFunName, HB_COMP_DECL );
extern void hb_macroGenPushString( const char * szText, HB_SIZE ulStrLen, HB_COMP_DECL );
extern void hb_macroGenPushString( const char * szText, HB_SIZE nStrLen, HB_COMP_DECL );
extern void hb_macroCodeBlockStart( HB_COMP_DECL );
extern void hb_macroCodeBlockEnd( HB_COMP_DECL );
extern int hb_macroLocalVarGetPos( const char * szVarName, HB_COMP_DECL );
extern HB_BOOL hb_macroIsValidMacroText( const char * szText, HB_SIZE ulLen );
extern HB_BOOL hb_macroIsValidMacroText( const char * szText, HB_SIZE nLen );
#endif /* HB_MACRO_SUPPORT */

4
harbour/include/hbregex.h
View File

@@ -135,10 +135,10 @@ typedef void * PHB_REGEX;
HB_EXTERN_BEGIN
extern HB_EXPORT PHB_REGEX hb_regexCompile( const char * szRegEx, HB_SIZE ulLen, int iFlags );
extern HB_EXPORT PHB_REGEX hb_regexCompile( const char * szRegEx, HB_SIZE nLen, int iFlags );
extern HB_EXPORT PHB_REGEX hb_regexGet( PHB_ITEM pRegExItm, int iFlags );
extern HB_EXPORT void hb_regexFree( PHB_REGEX pRegEx );
extern HB_EXPORT HB_BOOL hb_regexMatch( PHB_REGEX pRegEx, const char * szString, HB_SIZE UlLen, HB_BOOL fFull );
extern HB_EXPORT HB_BOOL hb_regexMatch( PHB_REGEX pRegEx, const char * szString, HB_SIZE nLen, HB_BOOL fFull );
HB_EXTERN_END

12
harbour/include/hbstack.h
View File

@@ -287,12 +287,12 @@ extern HB_EXPORT void hb_stackPop( void ); /* pops an item from th
extern void hb_stackPush( void ); /* pushes an item on to the stack */
extern void hb_stackPushReturn( void );
extern void hb_stackPopReturn( void );
extern void hb_stackRemove( HB_ISIZ lUntilPos );
extern void hb_stackRemove( HB_ISIZ nUntilPos );
extern HB_ISIZ hb_stackTopOffset( void );
extern HB_ISIZ hb_stackBaseOffset( void );
extern HB_ISIZ hb_stackTotalItems( void );
extern HB_ITEM_PTR hb_stackItem( HB_ISIZ iItemPos );
extern HB_ITEM_PTR hb_stackItem( HB_ISIZ nItemPos );
extern char * hb_stackDateBuffer( void );
/* stack management functions */
@@ -319,16 +319,16 @@ extern PHB_STACKRDD hb_stackRDD( void );
extern void ** hb_stackDebugInfo( void );
#ifdef _HB_API_INTERNAL_
extern void hb_stackDecrease( HB_SIZE ulItems );
extern void hb_stackDecrease( HB_SIZE nItems );
extern HB_ITEM_PTR hb_stackNewFrame( PHB_STACK_STATE pFrame, HB_USHORT uiParams );
extern void hb_stackOldFrame( PHB_STACK_STATE pFrame );
extern void hb_stackClearMemvarsBase( void );
extern HB_ITEM_PTR hb_stackLocalVariable( int *piFromBase );
extern HB_ITEM_PTR hb_stackLocalVariable( int * piFromBase );
extern PHB_ITEM ** hb_stackItemBasePtr( void );
extern HB_ISIZ hb_stackGetRecoverBase( void );
extern void hb_stackSetRecoverBase( HB_ISIZ lBase );
extern void hb_stackSetRecoverBase( HB_ISIZ nBase );
extern HB_USHORT hb_stackGetActionRequest( void );
extern void hb_stackSetActionRequest( HB_USHORT uiAction );
@@ -337,7 +337,7 @@ extern void * hb_stackGetStaticsBase( void );
extern PHB_ITEM hb_stackWithObjectItem( void );
extern HB_ISIZ hb_stackWithObjectOffset( void );
extern void hb_stackWithObjectSetOffset( HB_ISIZ );
extern void hb_stackWithObjectSetOffset( HB_ISIZ nOffset );
extern int * hb_stackKeyPolls( void );
extern HB_BOOL * hb_stackDebugRequest( void );

10
harbour/include/hbsxfunc.h
View File

@@ -65,12 +65,12 @@ HB_EXTERN_BEGIN
char * hb_sxDtoP( char * pDate, long lJulian );
long hb_sxPtoD( const char * pDate );
void hb_sxEnCrypt( const char * pSrc, char * pDst, const char * pKeyVal, HB_SIZE ulLen );
void hb_sxDeCrypt( const char * pSrc, char * pDst, const char * pKeyVal, HB_SIZE ulLen );
void hb_sxEnCrypt( const char * pSrc, char * pDst, const char * pKeyVal, HB_SIZE nLen );
void hb_sxDeCrypt( const char * pSrc, char * pDst, const char * pKeyVal, HB_SIZE nLen );
HB_BOOL hb_LZSSxDecompressMem( const char * pSrcBuf, HB_SIZE ulSrcLen, char * pDstBuf, HB_SIZE ulDstLen );
HB_BOOL hb_LZSSxCompressMem( const char * pSrcBuf, HB_SIZE ulSrcLen, char * pDstBuf, HB_SIZE ulDstLen, HB_SIZE * pulSize );
HB_BOOL hb_LZSSxCompressFile( HB_FHANDLE hInput, HB_FHANDLE hOutput, HB_SIZE * pulSize );
HB_BOOL hb_LZSSxDecompressMem( const char * pSrcBuf, HB_SIZE nSrcLen, char * pDstBuf, HB_SIZE nDstLen );
HB_BOOL hb_LZSSxCompressMem( const char * pSrcBuf, HB_SIZE nSrcLen, char * pDstBuf, HB_SIZE nDstLen, HB_SIZE * pnSize );
HB_BOOL hb_LZSSxCompressFile( HB_FHANDLE hInput, HB_FHANDLE hOutput, HB_SIZE * pnSize );
HB_BOOL hb_LZSSxDecompressFile( HB_FHANDLE hInput, HB_FHANDLE hOutput );
HB_EXTERN_END

12
harbour/include/hbxvm.h
View File

@@ -188,11 +188,11 @@ extern HB_EXPORT HB_BOOL hb_xvmDecEq( void );
extern HB_EXPORT HB_BOOL hb_xvmDecEqPop( void );
extern HB_EXPORT void hb_xvmArrayDim( HB_USHORT uiDimensions ); /* generates an uiDimensions Array and initialize those dimensions from the stack values */
extern HB_EXPORT void hb_xvmArrayGen( HB_SIZE ulElements ); /* generates an ulElements Array and fills it from the stack values */
extern HB_EXPORT void hb_xvmArrayGen( HB_SIZE nElements ); /* generates an nElements Array and fills it from the stack values */
extern HB_EXPORT HB_BOOL hb_xvmArrayPush( void ); /* pushes an array element to the stack, removing the array and the index from the stack */
extern HB_EXPORT HB_BOOL hb_xvmArrayPushRef( void ); /* pushes a reference to an array element to the stack, removing the array and the index from the stack */
extern HB_EXPORT HB_BOOL hb_xvmArrayPop( void ); /* pops a value from the stack */
extern HB_EXPORT void hb_xvmHashGen( HB_SIZE ulElements ); /* generates an ulElements Hash and fills it from the stack values */
extern HB_EXPORT void hb_xvmHashGen( HB_SIZE nElements ); /* generates an nElements Hash and fills it from the stack values */
extern HB_EXPORT void hb_xvmLocalName( HB_USHORT uiLocal, const char * szLocalName );
extern HB_EXPORT void hb_xvmStaticName( HB_BYTE bIsGlobal, HB_USHORT uiStatic, const char * szStaticName );
@@ -214,7 +214,7 @@ extern HB_EXPORT HB_BOOL hb_xvmMacroPopAliased( int bFlags );
extern HB_EXPORT HB_BOOL hb_xvmMacroSymbol( void );
extern HB_EXPORT HB_BOOL hb_xvmMacroText( void );
extern HB_EXPORT void hb_xvmPushStringHidden( int iMethod, const char * szText, HB_SIZE ulSize );
extern HB_EXPORT void hb_xvmPushStringHidden( int iMethod, const char * szText, HB_SIZE nSize );
extern HB_EXPORT void hb_xvmPushDouble( double dNumber, int iWidth, int iDec );
#ifdef HB_LONG_LONG_OFF
extern HB_EXPORT void hb_xvmPushLongLong( double dNumber );
@@ -235,14 +235,14 @@ extern HB_EXPORT void hb_xvmPushLongLong( HB_LONGLONG llNumber );
/*
* additional multi PCODE operations
*/
extern HB_EXPORT HB_BOOL hb_xvmArrayItemPush( HB_SIZE ulIndex );
extern HB_EXPORT HB_BOOL hb_xvmArrayItemPop( HB_SIZE ulIndex );
extern HB_EXPORT HB_BOOL hb_xvmArrayItemPush( HB_SIZE nIndex );
extern HB_EXPORT HB_BOOL hb_xvmArrayItemPop( HB_SIZE nIndex );
extern HB_EXPORT HB_BOOL hb_xvmMultByInt( HB_LONG lValue );
extern HB_EXPORT HB_BOOL hb_xvmDivideByInt( HB_LONG lValue );
extern HB_EXPORT HB_BOOL hb_xvmModulusByInt( HB_LONG lValue );
extern HB_EXPORT HB_BOOL hb_xvmAddInt( HB_LONG lValue );
extern HB_EXPORT void hb_xvmLocalSetInt( int iLocal, HB_LONG lValue );
/*extern HB_EXPORT void hb_xvmLocalSetStr( int iLocal, const char * pValue, HB_SIZE ulLen );*/
/*extern HB_EXPORT void hb_xvmLocalSetStr( int iLocal, const char * pValue, HB_SIZE nLen );*/
extern HB_EXPORT void hb_xvmPushFuncSymbol( PHB_SYMB pSym );
extern HB_EXPORT HB_BOOL hb_xvmLessThenInt( HB_LONG lValue );

16
harbour/src/vm/extend.c
View File

@@ -2030,15 +2030,15 @@ int hb_stornll( HB_LONGLONG llValue, int iParam )
}
#endif
int hb_stornint( HB_MAXINT lValue, int iParam )
int hb_stornint( HB_MAXINT nValue, int iParam )
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_stornint(%" PFHL "d, %d)", lValue, iParam));
HB_TRACE(HB_TR_DEBUG, ("hb_stornint(%" PFHL "d, %d)", nValue, iParam));
if( iParam == -1 )
{
hb_itemPutNInt( hb_stackReturnItem(), lValue );
hb_itemPutNInt( hb_stackReturnItem(), nValue );
return 1;
}
else if( iParam >= 0 && iParam <= hb_pcount() )
@@ -2047,7 +2047,7 @@ int hb_stornint( HB_MAXINT lValue, int iParam )
if( HB_IS_BYREF( pItem ) )
{
hb_itemPutNInt( hb_itemUnRef( pItem ), lValue );
hb_itemPutNInt( hb_itemUnRef( pItem ), nValue );
return 1;
}
}
@@ -2534,11 +2534,11 @@ int hb_storvnll( HB_LONGLONG llValue, int iParam, ... )
}
#endif
int hb_storvnint( HB_MAXINT lValue, int iParam, ... )
int hb_storvnint( HB_MAXINT nValue, int iParam, ... )
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_storvnint(%" PFHL "d, %d, ...)", lValue, iParam));
HB_TRACE(HB_TR_DEBUG, ("hb_storvnint(%" PFHL "d, %d, ...)", nValue, iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
@@ -2553,13 +2553,13 @@ int hb_storvnint( HB_MAXINT lValue, int iParam, ... )
int iRetVal;
va_list va;
va_start( va, iParam );
iRetVal = hb_arraySetNInt( pItem, va_arg( va, HB_SIZE ), lValue ) ? 1 : 0;
iRetVal = hb_arraySetNInt( pItem, va_arg( va, HB_SIZE ), nValue ) ? 1 : 0;
va_end( va );
return iRetVal;
}
else if( bByRef || iParam == -1 )
{
hb_itemPutNInt( pItem, lValue );
hb_itemPutNInt( pItem, nValue );
return 1;
}
}