/*
 * $Id: hb_api.txt 12560 2009-09-19 14:30:32Z april $
 */

/*
 * The following parts are Copyright of the individual authors.
 * www - http://www.harbour-project.org
 *
 * Copyright 1999 Antonio Linares <alinares@fivetech.com>
 *   Header file for the API
 * $SUBCATEGORY$
 *    Extend, Array API, misc API and base declarations
 *
 * See COPYING for licensing terms.
 *
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_parc()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *    Extend
 *  $ONELINER$
 *      Retrieve a string parameter
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_parc( int iParam, ... ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <iParam>
 *
 *      <...>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_parclen()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve a string parameter length
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_parclen( int iParam, ... ) --> ( ULONG )ulResult
 *  $ARGUMENTS$
 *      <iParam>
 *
 *      <...>
 *  $RETURNS$
 *      <ulResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_parcsiz()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve a by-reference string parameter length, including terminator
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_parcsiz( int iParam, ... ) --> ( ULONG )ulResult
 *  $ARGUMENTS$
 *      <iParam>
 *
 *      <...>
 *  $RETURNS$
 *      <ulResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_pards()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve a date as a string yyyymmdd
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_pards( int iParam, ... ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <iParam>
 *
 *      <...>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_pardsbuff()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve a date as a string yyyymmdd
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_pardsbuff( char * szDate, int iParam, ... ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <szDate>
 *
 *      <iParam>
 *
 *      <...>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_parinfa()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve length or element type of an array parameter
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_parinfa( int iParamNum, ULONG uiArrayIndex ) --> ( ULONG )ulResult
 *  $ARGUMENTS$
 *      <iParamNum>
 *
 *      <uiArrayIndex>
 *  $RETURNS$
 *      <ulResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_parinfo()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Determine the param count or data type
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_parinfo( int iParam ) --> ( int )iResult
 *  $ARGUMENTS$
 *      <iParam>
 *  $RETURNS$
 *      <iResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_parl()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve a logical parameter as an int
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_parl( int iParam, ... ) --> ( int )iResult
 *  $ARGUMENTS$
 *      <iParam>
 *
 *      <...>
 *  $RETURNS$
 *      <iResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_parnd()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve a numeric parameter as a double
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_parnd( int iParam, ... ) --> ( double )dResult
 *  $ARGUMENTS$
 *      <iParam>
 *
 *      <...>
 *  $RETURNS$
 *      <dResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_parni()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve a numeric parameter as a integer
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_parni( int iParam, ... ) --> ( int )iResult
 *  $ARGUMENTS$
 *      <iParam>
 *
 *      <...>
 *  $RETURNS$
 *      <iResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_parnl()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve a numeric parameter as a long
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_parnl( int iParam, ... ) --> ( long )lResult
 *  $ARGUMENTS$
 *      <iParam>
 *
 *      <...>
 *  $RETURNS$
 *      <lResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_param()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve a direct pointer to an item parameter
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_param( int iParam, int iMask ) --> ( PHB_ITEM ) pResult
 *  $ARGUMENTS$
 *      <iParam>  The 1-based parameter to retrieve.
 *
 *      <iMask>
 *  $RETURNS$
 *      hb_param() returns a direct pointer to an item on the eval stack.
 *
 *  $DESCRIPTION$
 *      This item will be removed (set to NIL) after a function cleanup,
 *      so if the item needs to survive the current function (e.g. copied
 *      to a static) you should use hb_itemParam instead.
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *      hb_itemParam()
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_pcount()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns the number of supplied parameters
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_pcount( void ) --> ( int )iResult
 *  $ARGUMENTS$
 *
 *  $RETURNS$
 *      <iResult>
 *  $DESCRIPTION$
 *      Note that when HB_API_MACROS is defined, this function is replaced with
 *      a macro: hb_pcount() --> ( ( int ) hb_stack.pBase->item.asSymbol.paramcnt )
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_ret()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Post a NIL return value
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_ret( void ) --> void
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *      Note that when HB_API_MACROS is defined, this function is replaced with
 *      a macro: hb_ret() --> hb_itemClear( &hb_stack.Return )
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_retc()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns a string
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_retc( char * szText )
 *  $ARGUMENTS$
 *      <szText>
 *  $DESCRIPTION$
 *      Note that when HB_API_MACROS is defined, this function is replaced with
 *      a macro: hb_retc( szText ) --> hb_itemPutC( &hb_stack.Return, szText )
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_retclen()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns a string with a specific length
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_retclen( char * szText, ULONG ulLen )
 *  $ARGUMENTS$
 *      <szText>
 *
 *      <ulLen>
 *  $DESCRIPTION$
 *      Note that when HB_API_MACROS is defined, this function is replaced with
 *      a macro: hb_retclen( szText, ulLen ) --> hb_itemPutCL( &hb_stack.Return, szText, ulLen )
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_retds()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns a date, must use yyyymmdd format
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_retds( char * szDate )
 *  $ARGUMENTS$
 *      <szDate>
 *  $DESCRIPTION$
 *      Note that when HB_API_MACROS is defined, this function is replaced with
 *      a macro: hb_retds( szDate ) --> hb_itemPutDS( &hb_stack.Return, szDate )
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_retd()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns a date
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_retd( long lYear, long lMonth, long lDay )
 *  $ARGUMENTS$
 *      <lYear>
 *
 *      <lMonth>
 *
 *      <lDay>
 *  $DESCRIPTION$
 *      Note that when HB_API_MACROS is defined, this function is replaced with
 *      a macro: hb_retd( lYear, lMonth, lDay ) --> hb_itemPutD( &hb_stack.Return, lYear, lMonth, lDay )
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_retdl()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns a long value as a julian date
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_retdl( long lJulian )
 *  $ARGUMENTS$
 *      <lJulian>
 *  $DESCRIPTION$
 *      Note that when HB_API_MACROS is defined, this function is replaced with
 *      a macro: hb_retdl( lJulian ) --> hb_itemPutDL( &hb_stack.Return, lJulian )
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_retl()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns a logical integer
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_retl( int iTrueFalse )
 *  $ARGUMENTS$
 *      <iTrueFalse>
 *  $DESCRIPTION$
 *      Note that when HB_API_MACROS is defined, this function is replaced with
 *      a macro: hb_retl( iLogical ) --> hb_itemPutL( &hb_stack.Return, iLogical ? TRUE : FALSE )
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_retnd()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns a double
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_retnd( double dNumber )
 *  $ARGUMENTS$
 *      <dNumber>
 *  $DESCRIPTION$
 *      Note that when HB_API_MACROS is defined, this function is replaced with
 *      a macro: hb_retnd( dNumber ) --> hb_itemPutND( &hb_stack.Return, dNumber )
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_retni()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns a integer number
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_retni( int iNumber )
 *  $ARGUMENTS$
 *      <iNumber>
 *  $DESCRIPTION$
 *      Note that when HB_API_MACROS is defined, this function is replaced with
 *      a macro: hb_retni( iNumber ) --> hb_itemPutNI( &hb_stack.Return, iNumber )
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_retnl()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns a long number
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_retnl( long lNumber )
 *  $ARGUMENTS$
 *      <lNumber>
 *  $DESCRIPTION$
 *      Note that when HB_API_MACROS is defined, this function is replaced with
 *      a macro: hb_retnl( lNumber ) --> hb_itemPutNL( &hb_stack.Return, lNumber )
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_retnlen()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns a double, with specific width and decimals
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_retnlen( double dNumber, int iWidth, int iDec )
 *  $ARGUMENTS$
 *      <dNumber>
 *
 *      <iWidth>
 *
 *      <iDec>
 *  $DESCRIPTION$
 *      Note that when HB_API_MACROS is defined, this function is replaced with
 *      a macro: hb_retnlen( dNumber, iWidth, iDec ) --> hb_itemPutNLen( &hb_stack.Return, dNumber, iWidth, iDec )
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_retndlen()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns a double, with specific width and decimals
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_retndlen( double dNumber, int iWidth, int iDec )
 *  $ARGUMENTS$
 *      <dNumber>
 *
 *      <iWidth>
 *
 *      <iDec>
 *  $DESCRIPTION$
 *      Note that when HB_API_MACROS is defined, this function is replaced with
 *      a macro: hb_retndlen( dNumber, iWidth, iDec ) --> hb_itemPutNDLen( &hb_stack.Return, dNumber, iWidth, iDec )
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_retnilen()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns a integer number, with specific width
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_retnilen( int iNumber, int iWidth )
 *  $ARGUMENTS$
 *      <iNumber>
 *
 *      <iWidth>
 *  $DESCRIPTION$
 *      Note that when HB_API_MACROS is defined, this function is replaced with
 *      a macro: hb_retnilen( iNumber, iWidth ) --> hb_itemPutNILen( &hb_stack.Return, iNumber, iWidth )
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_retnllen()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns a long number, with specific width
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_retnllen( long lNumber, int iWidth )
 *  $ARGUMENTS$
 *      <lNumber>
 *
 *      <iWidth>
 *  $DESCRIPTION$
 *      Note that when HB_API_MACROS is defined, this function is replaced with
 *      a macro: hb_retnllen( lNumber, iWidth ) --> hb_itemPutNLLen( &hb_stack.Return, lNumber, iWidth )
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_reta()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns an array with a specific length
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_reta( ULONG ulLen )
 *  $ARGUMENTS$
 *      <ulLen>
 *  $DESCRIPTION$
 *      Note that when HB_API_MACROS is defined, this function is replaced with
 *      a macro: hb_reta( ulLen ) --> hb_arrayNew( &hb_stack.Return, ulLen )
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_storc()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Stores a szString on a variable by reference
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_storc( char * szText, int iParam, ... )
 *  $ARGUMENTS$
 *      <szText>
 *
 *      <iParam>
 *
 *      <...>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_storclen()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Stores a fixed length string on a variable by reference
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_storclen( char * szText, ULONG ulLength, int iParam, ... )
 *  $ARGUMENTS$
 *      <szText>
 *
 *      <ulLength>
 *
 *      <iParam>
 *
 *      <...>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_stords()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      SzDate must have yyyymmdd format
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_stords( char * szDate, int iParam, ... )
 *  $ARGUMENTS$
 *      <szDate>
 *
 *      <iParam>
 *
 *      <...>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_storl()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Stores a logical integer on a variable by reference
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_storl( int iLogical, int iParam, ... )
 *  $ARGUMENTS$
 *      <iLogical>
 *
 *      <iParam>
 *
 *      <...>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_storni()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Stores an integer on a variable by reference
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_storni( int iValue, int iParam, ... )
 *  $ARGUMENTS$
 *      <iValue>
 *
 *      <iParam>
 *
 *      <...>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_stornl()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Stores a long on a variable by reference
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_stornl( long lValue, int iParam, ... )
 *  $ARGUMENTS$
 *      <lValue>
 *
 *      <iParam>
 *
 *      <...>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_stornd()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Stores a double on a variable by reference
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_stornd( double dValue, int iParam, ... )
 *  $ARGUMENTS$
 *      <dValue>
 *
 *      <iParam>
 *
 *      <...>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_xinit()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Initialize fixed memory subsystem
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_xinit( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_xexit()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Deinitialize fixed memory subsystem
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_xexit( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_xalloc()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Allocates memory, returns NULL on failure
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_xalloc( ULONG ulSize ) --> ( void * )pResult
 *  $ARGUMENTS$
 *      <ulSize>
 *  $RETURNS$
 *      <pResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_xgrab()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Allocates memory, exits on failure
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_xgrab( ULONG ulSize ) --> ( void * )pResult
 *  $ARGUMENTS$
 *      <ulSize>
 *  $RETURNS$
 *      <pResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_xfree()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Frees memory
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_xfree( void * pMem )
 *  $ARGUMENTS$
 *      <pMem>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_xrealloc()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Reallocates memory
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_xrealloc( void * pMem, ULONG ulSize ) --> ( void * )pResult
 *  $ARGUMENTS$
 *      <pMem>
 *
 *      <ulSize>
 *  $RETURNS$
 *      <pResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_xsize()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns the size of an allocated memory block
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_xsize( void * pMem ) --> ( ULONG )ulResult
 *  $ARGUMENTS$
 *      <pMem>
 *  $RETURNS$
 *      <ulResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_xquery()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Query different types of memory information
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_xquery( USHORT uiMode ) --> ( ULONG )ulResult
 *  $ARGUMENTS$
 *      <uiMode>
 *  $RETURNS$
 *      <ulResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_xmemcpy()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Copy more than memcpy() can
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_xmemcpy( void * pDestArg, void * pSourceArg, ULONG ulLen ) --> ( void * )pResult
 *  $ARGUMENTS$
 *      <pDestArg>
 *
 *      <pSourceArg>
 *
 *      <ulLen>
 *  $RETURNS$
 *      <pResult>
 *  $DESCRIPTION$
 *      If UINT_MAX is defined as ULONG_MAX then this function is replaced
 *      by a macro replacement to memcpy()
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_xmemset()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Set more than memset() can
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_xmemset( void * pDestArg, int iFill, ULONG ulLen ) --> ( void * )pResult
 *  $ARGUMENTS$
 *      <pDestArg>
 *
 *      <iFill>
 *
 *      <ulLen>
 *  $RETURNS$
 *      <pResult>
 *  $DESCRIPTION$
 *      If UINT_MAX is defined as ULONG_MAX then this function is replaced
 *      by a macro replacement to memset()
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayNew()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Creates a new array
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayNew( PHB_ITEM pItem, ULONG ulLen ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <pItem>
 *
 *      <ulLen>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayLen()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrives the array len
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayLen( PHB_ITEM pArray ) --> ( ULONG )ulResult
 *  $ARGUMENTS$
 *      <pArray>
 *  $RETURNS$
 *      <ulResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayIsObject()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrives if the array is an object
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayIsObject( PHB_ITEM pArray ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <pArray>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayAdd()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Add a new item to the end of an array item
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayAdd( PHB_ITEM pArray, PHB_ITEM pItemValue ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <pItemValue>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayIns()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Insert a nil item into an array, without changing the length
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayIns( PHB_ITEM pArray, ULONG ulIndex ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <ulIndex>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayDel()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Delete an array item, without changing length
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayDel( PHB_ITEM pArray, ULONG ulIndex ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <ulIndex>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arraySize()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Sets the array total length
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arraySize( PHB_ITEM pArray, ULONG ulLen ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <ulLen>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayLast()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve last item in an array
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayLast( PHB_ITEM pArray, PHB_ITEM pResult ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <pResult>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayRelease()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Releases an array - don't call it - use ItemRelease() !!!
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayRelease( PHB_ITEM pArray ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <pArray>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arraySet()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Sets an array element
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arraySet( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <ulIndex>
 *
 *      <pItem>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayGet()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieves an item
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayGet( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <ulIndex>
 *
 *      <pItem>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayGetItemPtr()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns pointer to specified element of the array
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayGetItemPtr( PHB_ITEM pArray, ULONG ulIndex ) --> ( PHB_ITEM )pResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <ulIndex>
 *  $RETURNS$
 *      <pResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayCopyC()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Copy a string into an array item
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayCopyC( PHB_ITEM pArray, ULONG ulIndex, char * szBuffer, ULONG ulLen ) --> ( ULONG )ulResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <ulIndex>
 *
 *      <szBuffer>
 *
 *      <ulLen>
 *  $RETURNS$
 *      <ulResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayGetC()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieves the string contained on an array element
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayGetC( PHB_ITEM pArray, ULONG ulIndex ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <ulIndex>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayGetCPtr()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieves the string pointer on an array element
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayGetCPtr( PHB_ITEM pArray, ULONG ulIndex ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <ulIndex>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayGetCLen()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieves the string length contained on an array element
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayGetCLen( PHB_ITEM pArray, ULONG ulIndex ) --> ( ULONG )ulResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <ulIndex>
 *  $RETURNS$
 *      <ulResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayGetL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieves the logical value contained on an array element
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayGetL( PHB_ITEM pArray, ULONG ulIndex ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <ulIndex>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayGetNI()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieves the int value contained on an array element
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayGetNI( PHB_ITEM pArray, ULONG ulIndex ) --> ( int )iResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <ulIndex>
 *  $RETURNS$
 *      <iResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayGetNL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieves the long numeric value contained on an array element
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayGetNL( PHB_ITEM pArray, ULONG ulIndex ) --> ( long )lResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <ulIndex>
 *  $RETURNS$
 *      <lResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayGetND()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieves the double value contained on an array element
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayGetND( PHB_ITEM pArray, ULONG ulIndex ) --> ( double )dResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <ulIndex>
 *  $RETURNS$
 *      <dResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayGetDS()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieves the date value contained in an array element
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayGetDS( PHB_ITEM pArray, ULONG ulIndex, char * szDate ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <ulIndex>
 *
 *      <szDate>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayGetDL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieves the date value contained in an array element, as a long integer
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayGetDL( PHB_ITEM pArray, ULONG ulIndex ) --> ( long )lResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <ulIndex>
 *  $RETURNS$
 *      <lResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayGetType()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieves the type of an array item
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayGetType( PHB_ITEM pArray, ULONG ulIndex ) --> ( USHORT )usResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <ulIndex>
 *  $RETURNS$
 *      <usResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayFill()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Fill an array with a given item
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayFill( PHB_ITEM pArray, PHB_ITEM pValue, ULONG * pulStart, ULONG * pulCount ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <pValue>
 *
 *      <pulStart>
 *
 *      <pulCount>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayScan()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Scan an array for a given item, or until code-block item returns TRUE
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayScan( PHB_ITEM pArray, PHB_ITEM pValue, ULONG * pulStart, ULONG * pulCount ) --> ( ULONG )ulResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <pValue>
 *
 *      <pulStart>
 *
 *      <pulCount>
 *  $RETURNS$
 *      <ulResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayEval()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Execute a code-block for every element of an array item
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayEval( PHB_ITEM pArray, PHB_ITEM bBlock, ULONG * pulStart, ULONG * pulCount ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <bBlock>
 *
 *      <pulStart>
 *
 *      <pulCount>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayCopy()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Copy items from one array to another
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayCopy( PHB_ITEM pSrcArray, PHB_ITEM pDstArray, ULONG * pulStart, ULONG * pulCount, ULONG * pulTarget ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <pSrcArray>
 *
 *      <pDstArray>
 *
 *      <pulStart>
 *
 *      <pulCount>
 *
 *      <pulTarget>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arrayClone()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns a duplicate of an existing array, including all nested items
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayClone( PHB_ITEM pArray ) --> ( PHB_ITEM )pResult
 *  $ARGUMENTS$
 *      <pArray>
 *  $RETURNS$
 *      <pResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_arraySort()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Sorts an array item
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arraySort( PHB_ITEM pArray, ULONG * pulStart, ULONG * pulCount, PHB_ITEM pBlock ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <pArray>
 *
 *      <pulStart>
 *
 *      <pulCount>
 *
 *      <pBlock>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_stricmp()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Compare two strings without regards to case
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_stricmp( const char * s1, const char * s2 ) --> ( int )iResult
 *  $ARGUMENTS$
 *      <s1>
 *
 *      <s2>
 *  $RETURNS$
 *      <iResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_strnicmp()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Compare two string without regards to case, limited by length
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_strnicmp( const char * s1, const char * s2, ULONG ulLen ) --> ( int )iResult
 *  $ARGUMENTS$
 *      <s1>
 *
 *      <s2>
 *
 *      <ulLen>
 *  $RETURNS$
 *      <iResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_strupr()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Convert a string in-place to upper-case
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_strupr( char * pszText ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <pszText>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_strdup()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns a pointer to a newly allocated copy of the source string
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_strdup( const char * pszText ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <pszText>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_strMatchRegExp()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Compare two strings using a regular expression pattern
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_strMatchRegExp( const char * szString, const char * szMask ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <szString>
 *
 *      <szMask>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_strEmpty()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns whether a string contains only white space
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_strEmpty( const char * szText, ULONG ulLen ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <szText>
 *
 *      <ulLen>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_strDescend()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Copy a string to a buffer, inverting each character
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_strDescend( char * szStringTo, const char * szStringFrom, ULONG ulLen )
 *  $ARGUMENTS$
 *      <szStringTo>
 *
 *      <szStringFrom>
 *
 *      <ulLen>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_strAt()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns an index to a sub-string within another string
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_strAt( const char * szSub, ULONG ulSubLen, const char * szText, ULONG ulLen ) --> ( ULONG )ulResult
 *  $ARGUMENTS$
 *      <szSub>
 *
 *      <ulSubLen>
 *
 *      <szText>
 *
 *      <ulLen>
 *  $RETURNS$
 *      <ulResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_strUpper()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Convert an existing string buffer to upper case
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_strUpper( char * szText, ULONG ulLen ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <szText>
 *
 *      <ulLen>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_strLower()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Convert an existing string buffer to lower case
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_strLower( char * szText, ULONG ulLen ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <szText>
 *
 *      <ulLen>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_strncpyUpper()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Copy an existing string buffer to another buffer, as upper case
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_strncpyUpper( char * pDest, const char * pSource, ULONG ulLen ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <pDest>
 *
 *      <pSource>
 *
 *      <ulLen>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_strVal()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Return the numeric value of a character string representation of a number
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_strVal( const char * szText, ULONG ulLen ) --> ( double )dResult
 *  $ARGUMENTS$
 *      <szText>
 *
 *      <ulLen>
 *  $RETURNS$
 *      <dResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_strLTrim()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Return a pointer to the first non-white space character
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_strLTrim( const char * szText, ULONG * ulLen ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <szText>
 *
 *      <ulLen>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_strRTrimLen()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Return length of a string, ignoring trailing white space (or true spaces)
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_strRTrimLen( const char * szText, ULONG ulLen, BOOL bAnySpace ) --> ( ULONG )ulResult
 *  $ARGUMENTS$
 *      <szText>
 *
 *      <ulLen>
 *
 *      <bAnySpace>
 *  $RETURNS$
 *      <ulResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_numRound()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Round a number to a specific number of digits
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_numRound( double dResult, int iDec ) --> ( double )dResult
 *  $ARGUMENTS$
 *      <dResult>
 *
 *      <iDec>
 *  $RETURNS$
 *      <dResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_clsReleaseAll()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Releases all defined classes
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_clsReleaseAll( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_objGetClsName()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieves an object class name
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_objGetClsName( PHB_ITEM pObject ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <pObject>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_objGetMethod()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns the method pointer of a object class
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_objGetMethod( PHB_ITEM pObject, PHB_SYMB pSymMsg ) --> ( PHB_FUNC )hResult
 *  $ARGUMENTS$
 *      <pObject>
 *
 *      <pSymMsg>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_objHasMsg()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns TRUE/FALSE whether szString is an existing message for object
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_objHasMsg( PHB_ITEM pObject, char * szString ) --> ( ULONG )ulResult
 *  $ARGUMENTS$
 *      <pObject>
 *
 *      <szString>
 *  $RETURNS$
 *      <ulResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_dynsymGet()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Finds and creates a dynamic symbol if not found
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_dynsymGet( char * szName ) --> ( PHB_DYNS )hResult
 *  $ARGUMENTS$
 *      <szName>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_dynsymNew()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Creates a new dynamic symbol based on a local one
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_dynsymNew( PHB_SYMB pSymbol ) --> ( PHB_DYNS )hResult
 *  $ARGUMENTS$
 *      <pSymbol>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_dynsymFind()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Finds a dynamic symbol
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_dynsymFind( char * szName ) --> ( PHB_DYNS )hResult
 *  $ARGUMENTS$
 *      <szName>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_dynsymFindName()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Converts to uppercase and finds a dynamic symbol
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_dynsymFindName( char * szName ) --> ( PHB_DYNS )hResult
 *  $ARGUMENTS$
 *      <szName>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_dynsymLog()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Displays all dynamic symbols
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_dynsymLog( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_dynsymRelease()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Releases the memory of the dynamic symbol table
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_dynsymRelease( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_dynsymEval()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Enumerates all dynamic symbols
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_dynsymEval( PHB_DYNS_FUNC pFunction, void * Cargo )
 *  $ARGUMENTS$
 *      <pFunction>
 *
 *      <Cargo>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_cmdargInit()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Initialize command line argument API's
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_cmdargInit( int argc, char * argv[] )
 *  $ARGUMENTS$
 *      <argc>
 *
 *      <argv[]>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_cmdargARGC()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve command line argument count
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_cmdargARGC( void ) --> ( int )iResult
 *  $ARGUMENTS$
 *
 *  $RETURNS$
 *      <iResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_cmdargARGV()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve command line argument buffer pointer
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_cmdargARGV( void ) --> ( char ** )ppszResult
 *  $ARGUMENTS$
 *
 *  $RETURNS$
 *      <ppszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_cmdargIsInternal()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Determine if a string is an internal setting
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_cmdargIsInternal( const char * szArg ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <szArg>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_cmdargCheck()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Check if a given internal switch (like //INFO) was set
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_cmdargCheck( const char * pszName ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <pszName>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_cmdargString()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns the string value of an internal switch (like //TEMPPATH:"C:\")
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_cmdargString( const char * pszName ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <pszName>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_cmdargNum()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Returns the numeric value of an internal switch (like //F:90)
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_cmdargNum( const char * pszName ) --> ( int )iResult
 *  $ARGUMENTS$
 *      <pszName>
 *  $RETURNS$
 *      <iResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_cmdargProcessVM()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Check for command line internal arguments
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_cmdargProcessVM( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_symbolNew()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Create a new symbol
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_symbolNew( char * szName ) --> ( PHB_SYMB )hResult
 *  $ARGUMENTS$
 *      <szName>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_codeblockNew()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Create a code-block
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_codeblockNew( BYTE * pBuffer, USHORT uiLocals, USHORT * pLocalPosTable, PHB_SYMB pSymbols ) --> ( HB_CODEBLOCK_PTR )hResult
 *  $ARGUMENTS$
 *      <pBuffer>
 *
 *      <uiLocals>
 *
 *      <pLocalPosTable>
 *
 *      <pSymbols>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_codeblockMacroNew()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_codeblockMacroNew( BYTE * pBuffer, USHORT usLen ) --> ( HB_CODEBLOCK_PTR )hResult
 *  $ARGUMENTS$
 *      <pBuffer>
 *
 *      <usLen>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_codeblockDelete()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Delete a codeblock
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_codeblockDelete( HB_ITEM_PTR pItem )
 *  $ARGUMENTS$
 *      <pItem>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_codeblockGetVar()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Get local variable referenced in a codeblock
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_codeblockGetVar( PHB_ITEM pItem, LONG iItemPos ) --> ( PHB_ITEM )pResult
 *  $ARGUMENTS$
 *      <pItem>
 *
 *      <iItemPos>
 *  $RETURNS$
 *      <pResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_codeblockGetRef()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Get local variable passed by reference
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_codeblockGetRef( PHB_ITEM pItem, PHB_ITEM pRefer ) --> ( PHB_ITEM )pResult
 *  $ARGUMENTS$
 *      <pItem>
 *
 *      <pRefer>
 *  $RETURNS$
 *      <pResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_codeblockEvaluate()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Evaluate a codeblock
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_codeblockEvaluate( HB_ITEM_PTR pItem )
 *  $ARGUMENTS$
 *      <pItem>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_codeblockCopy()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Copy a codeblock
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_codeblockCopy( PHB_ITEM pDest, PHB_ITEM pSource )
 *  $ARGUMENTS$
 *      <pDest>
 *
 *      <pSource>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_memvarValueNew()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Create a new global value
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_memvarValueNew( HB_ITEM_PTR pSource, BOOL bTrueMemvar ) --> ( HB_HANDLE )hResult
 *  $ARGUMENTS$
 *      <pSource>
 *
 *      <bTrueMemvar>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_memvarValueBaseAddress()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve the base address of the values table
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_memvarValueBaseAddress( void ) --> ( HB_VALUE_PTR * )phResult
 *  $ARGUMENTS$
 *
 *  $RETURNS$
 *      <phResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_memvarsInit()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Initialize the memvar API system
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_memvarsInit( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_memvarsRelease()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Clear all PUBLIC and PRIVATE variables
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_memvarsRelease( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_memvarsFree()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Release the memvar API system
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_memvarsFree( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_memvarValueIncRef()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Increase the reference count of a global value
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_memvarValueIncRef( HB_HANDLE hValue )
 *  $ARGUMENTS$
 *      <hValue>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_memvarValueDecRef()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Decrease the reference count of a global value
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_memvarValueDecRef( HB_HANDLE hValue )
 *  $ARGUMENTS$
 *      <hValue>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_memvarSetValue()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Copy an item into a symbol
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_memvarSetValue( PHB_SYMB pMemvarSymb, HB_ITEM_PTR pItem )
 *  $ARGUMENTS$
 *      <pMemvarSymb>
 *
 *      <pItem>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_memvarGet()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Copy an symbol value into an item
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_memvarGet( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb ) --> ( HB_ERRCODE )hResult
 *  $ARGUMENTS$
 *      <pItem>
 *
 *      <pMemvarSymb>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_memvarGetValue()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Copy an symbol value into an item, with error trapping
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_memvarGetValue( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb )
 *  $ARGUMENTS$
 *      <pItem>
 *
 *      <pMemvarSymb>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_memvarGetRefer()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Copy a reference to a symbol value into an item, with error trapping
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_memvarGetRefer( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb )
 *  $ARGUMENTS$
 *      <pItem>
 *
 *      <pMemvarSymb>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_memvarGetPrivatesBase()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve current PRIVATE variables stack base
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_memvarGetPrivatesBase( void ) --> ( ULONG )ulResult
 *  $ARGUMENTS$
 *
 *  $RETURNS$
 *      <ulResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_memvarSetPrivatesBase()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Release PRIVATE variables created after specified base
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_memvarSetPrivatesBase( ULONG ulBase )
 *  $ARGUMENTS$
 *      <ulBase>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_memvarNewParameter()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_memvarNewParameter( PHB_SYMB pSymbol, PHB_ITEM pValue )
 *  $ARGUMENTS$
 *      <pSymbol>
 *
 *      <pValue>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_memvarGetStrValuePtr()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_memvarGetStrValuePtr( char * szVarName, ULONG *pulLen ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <szVarName>
 *
 *      <*pulLen>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_memvarCreateFromItem()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_memvarCreateFromItem( PHB_ITEM pMemvar, BYTE bScope, PHB_ITEM pValue )
 *  $ARGUMENTS$
 *      <pMemvar>
 *
 *      <bScope>
 *
 *      <pValue>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_memvarScope()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve scope of a dynamic variable symbol
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_memvarScope( char * szVarName, ULONG ulLength ) --> ( int )iResult
 *  $ARGUMENTS$
 *      <szVarName>
 *
 *      <ulLength>
 *  $RETURNS$
 *      <iResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_conInit()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Initialize the console API system
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_conInit( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_conRelease()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Release the console API system
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_conRelease( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_conNewLine()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve a pointer to a static buffer containing new-line characters
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_conNewLine( void ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_conOutStd()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Output an string to STDOUT
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_conOutStd( char * pStr, ULONG ulLen )
 *  $ARGUMENTS$
 *      <pStr>
 *
 *      <ulLen>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_conOutErr()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Output an string to STDERR
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_conOutErr( char * pStr, ULONG ulLen )
 *  $ARGUMENTS$
 *      <pStr>
 *
 *      <ulLen>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_conSetCursor()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve and optionally set cursor shape
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_conSetCursor( BOOL bSetCursor, USHORT usNewCursor ) --> ( USHORT )usResult
 *  $ARGUMENTS$
 *      <bSetCursor>
 *
 *      <usNewCursor>
 *  $RETURNS$
 *      <usResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_conSetColor()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve and optionally set console color
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_conSetColor( char * szColor ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <szColor>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_conXSaveRestRelease()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Release the save/restore API
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_conXSaveRestRelease( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_compReservedName()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Determines if a string contains a reserve word
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_compReservedName( char * szName ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <szName>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_procname()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve a procedure name into a buffer
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_procname( int iLevel, char * szName ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <iLevel>
 *
 *      <szName>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_macroGetValue()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieve results of a macro expansion
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_macroGetValue( HB_ITEM_PTR pItem )
 *  $ARGUMENTS$
 *      <pItem>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_macroSetValue()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Assign a value to a macro-expression item
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_macroSetValue( HB_ITEM_PTR pItem )
 *  $ARGUMENTS$
 *      <pItem>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_macroTextValue()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Macro text substitution
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_macroTextValue( HB_ITEM_PTR pItem )
 *  $ARGUMENTS$
 *      <pItem>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_macroPushSymbol()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Handle a macro function calls, e.g. var := &macro()
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_macroPushSymbol( HB_ITEM_PTR pItem )
 *  $ARGUMENTS$
 *      <pItem>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_macroRun()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Executes pcode compiled by macro compiler
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_macroRun( HB_MACRO_PTR pMacro )
 *  $ARGUMENTS$
 *      <pMacro>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_macroCompile()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Compile a string and return a pcode buffer
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_macroCompile( char * szString ) --> ( HB_MACRO_PTR )hResult
 *  $ARGUMENTS$
 *      <szString>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_macroDelete()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Release all memory allocated for macro evaluation
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_macroDelete( HB_MACRO_PTR pMacro )
 *  $ARGUMENTS$
 *      <pMacro>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_macroTextSubst()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Substitute macro variables occurences within a given string
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_macroTextSubst( char * szString, ULONG *pulStringLen ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <szString>
 *
 *      <*pulStringLen>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_macroIsIdent()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Determine if a string is a valid function or variable name
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_macroIsIdent( char * szString ) --> ( BOOL )bResult
 *  $ARGUMENTS$
 *      <szString>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_macroPopAliasedValue()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Compiles and evaluates an aliased macro expression
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_macroPopAliasedValue( HB_ITEM_PTR pAlias, HB_ITEM_PTR pVar )
 *  $ARGUMENTS$
 *      <pAlias>
 *
 *      <pVar>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_macroPushAliasedValue()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Compiles and evaluates an aliased macro expression
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_macroPushAliasedValue( HB_ITEM_PTR pAlias, HB_ITEM_PTR pVar )
 *  $ARGUMENTS$
 *      <pAlias>
 *
 *      <pVar>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_macroGetType()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Determine the type of an expression
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_macroGetType( HB_ITEM_PTR pItem ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *      <pItem>
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_gcAlloc()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Allocates a memory controlled by the garbage collector
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_gcAlloc( ULONG ulSize, HB_GARBAGE_FUNC_PTR pFunc ) --> ( void * )pResult
 *  $ARGUMENTS$
 *      <ulSize>
 *
 *      <pFunc>
 *  $RETURNS$
 *      <pResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_gcFree()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Deallocates a memory allocated by the garbage collector
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_gcFree( void *pAlloc )
 *  $ARGUMENTS$
 *      <*pAlloc>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_gcLock()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Do not release passed memory block
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_gcLock( void *pAlloc ) --> ( void * )pResult
 *  $ARGUMENTS$
 *      <*pAlloc>
 *  $RETURNS$
 *      <pResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_gcUnlock()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Passed block is allowed to be released
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_gcUnlock( void *pAlloc ) --> ( void * )pResult
 *  $ARGUMENTS$
 *      <*pAlloc>
 *  $RETURNS$
 *      <pResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_gcLockItem()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Do not release a memory block stored inside an item
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_gcLockItem( HB_ITEM_PTR pItem )
 *  $ARGUMENTS$
 *      <pItem>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_gcUnlockItem()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Allow to release the item
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_gcUnlockItem( HB_ITEM_PTR pItem )
 *  $ARGUMENTS$
 *      <pItem>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_gcCollect()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Checks if a single memory block can be released
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_gcCollect( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_gcCollectAll()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Checks if all memory blocks can be released
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_gcCollectAll( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_gcItemRef()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Checks if passed item refers passed memory block pointer
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_gcItemRef( HB_ITEM_PTR pItem )
 *  $ARGUMENTS$
 *      <pItem>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_vmIsLocalRef()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Hvm.c - mark all local variables as used
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_vmIsLocalRef( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_vmIsStaticRef()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Hvm.c - mark all static variables as used
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_vmIsStaticRef( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_memvarsIsMemvarRef()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Memvars.c - mark all memvar variables as used
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_memvarsIsMemvarRef( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_clsIsClassRef()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Classes.c - mark all class internals as used
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_clsIsClassRef( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_codeblockDeleteGarbage()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Clear a codeblock before releasing by the GC
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_codeblockDeleteGarbage( void * Cargo )
 *  $ARGUMENTS$
 *      <Cargo>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_arrayReleaseGarbage()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Clear an array before releasing by the GC
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_arrayReleaseGarbage( void * Cargo )
 *  $ARGUMENTS$
 *      <Cargo>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_idleState()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Services a single idle state
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_idleState( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_idleReset()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Services a single idle state
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_idleReset( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_idleShutDown()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Closes all background tasks
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_idleShutDown( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_verPlatform()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieves a newly allocated buffer containing platform version
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_verPlatform( void ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_verCompiler()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieves a newly allocated buffer containing compiler version
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_verCompiler( void ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_verHarbour()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Retrieves a newly allocated buffer containing harbour version
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_verHarbour( void ) --> ( char * )pszResult
 *  $ARGUMENTS$
 *
 *  $RETURNS$
 *      <pszResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_verBuildInfo()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      Display harbour, compiler, and platform versions to standard console
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapi.h>
 *      hb_verBuildInfo( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is vm
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      HB_IS_OF_TYPE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      HB_IS_OF_TYPE( p, t ) --> <see ( ( ( p )->type & ~HB_IT_BYREF ) == t )>
 *  $ARGUMENTS$
 *      <p>
 *
 *      <t>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      HB_IS_BYREF()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      HB_IS_BYREF( p ) --> <see ( ( p )->type & HB_IT_BYREF )>
 *  $ARGUMENTS$
 *      <p>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      HB_IS_ARRAY()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      HB_IS_ARRAY( p ) --> <see HB_IS_OF_TYPE( p, HB_IT_ARRAY )>
 *  $ARGUMENTS$
 *      <p>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      HB_IS_NIL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      HB_IS_NIL( p ) --> <see HB_IS_OF_TYPE( p, HB_IT_NIL )>
 *  $ARGUMENTS$
 *      <p>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      HB_IS_BLOCK()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      HB_IS_BLOCK( p ) --> <see HB_IS_OF_TYPE( p, HB_IT_BLOCK )>
 *  $ARGUMENTS$
 *      <p>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      HB_IS_DATE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      HB_IS_DATE( p ) --> <see HB_IS_OF_TYPE( p, HB_IT_DATE )>
 *  $ARGUMENTS$
 *      <p>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      HB_IS_DOUBLE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      HB_IS_DOUBLE( p ) --> <see HB_IS_OF_TYPE( p, HB_IT_DOUBLE )>
 *  $ARGUMENTS$
 *      <p>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      HB_IS_INTEGER()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      HB_IS_INTEGER( p ) --> <see HB_IS_OF_TYPE( p, HB_IT_INTEGER )>
 *  $ARGUMENTS$
 *      <p>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      HB_IS_LOGICAL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      HB_IS_LOGICAL( p ) --> <see HB_IS_OF_TYPE( p, HB_IT_LOGICAL )>
 *  $ARGUMENTS$
 *      <p>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      HB_IS_LONG()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      HB_IS_LONG( p ) --> <see HB_IS_OF_TYPE( p, HB_IT_LONG )>
 *  $ARGUMENTS$
 *      <p>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      HB_IS_NUMERIC()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      HB_IS_NUMERIC( p ) --> <see ( ( p )->type & HB_IT_NUMERIC )>
 *  $ARGUMENTS$
 *      <p>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      HB_IS_OBJECT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      HB_IS_OBJECT( p ) --> <see HB_IS_OF_TYPE( p, HB_IT_OBJECT )>
 *  $ARGUMENTS$
 *      <p>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      HB_IS_STRING()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      HB_IS_STRING( p ) --> <see ( ( ( p )->type & ~( HB_IT_BYREF | HB_IT_MEMOFLAG ) ) == HB_IT_STRING )>
 *  $ARGUMENTS$
 *      <p>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      HB_IS_MEMO()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      HB_IS_MEMO( p ) --> <see HB_IS_OF_TYPE( p, HB_IT_MEMO )>
 *  $ARGUMENTS$
 *      <p>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      HB_IS_SYMBOL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      HB_IS_SYMBOL( p ) --> <see HB_IS_OF_TYPE( p, HB_IT_SYMBOL )>
 *  $ARGUMENTS$
 *      <p>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      HB_IS_MEMVAR()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      HB_IS_MEMVAR( p ) --> <see HB_IS_OF_TYPE( p, HB_IT_MEMVAR )>
 *  $ARGUMENTS$
 *      <p>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      HB_IS_POINTER()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      HB_IS_POINTER( p ) --> <see HB_IS_OF_TYPE( p, HB_IT_POINTER )>
 *  $ARGUMENTS$
 *      <p>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      ISNIL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *      NOTE: Intentionally using a different method
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      ISNIL( n ) --> <see ( hb_param( n, HB_IT_ANY ) == NULL || HB_IS_NIL( hb_param( n, HB_IT_ANY ) ) )>
 *  $ARGUMENTS$
 *      <n>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      ISCHAR()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      ISCHAR( n ) --> <see ( hb_param( n, HB_IT_STRING ) != NULL )>
 *  $ARGUMENTS$
 *      <n>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      ISNUM()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      ISNUM( n ) --> <see ( hb_param( n, HB_IT_NUMERIC ) != NULL )>
 *  $ARGUMENTS$
 *      <n>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      ISLOG()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *    Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      ISLOG( n ) --> <see ( hb_param( n, HB_IT_LOGICAL ) != NULL )>
 *  $ARGUMENTS$
 *      <n>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      ISDATE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *    Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      ISDATE( n ) --> <see ( hb_param( n, HB_IT_DATE ) != NULL )>
 *  $ARGUMENTS$
 *      <n>
 *  $RETURNS$
 *      <see ( hb_param( n, HB_IT_DATE ) != NULL )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      ISMEMO()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *    Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      ISMEMO( n ) --> <see ( hb_param( n, HB_IT_MEMO ) != NULL )>
 *  $ARGUMENTS$
 *      <n>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      ISBYREF()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *    Extend
 *  $ONELINER$
 *      NOTE: Intentionally using a different method
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      ISBYREF( n ) --> <see ( hb_parinfo( n ) & HB_IT_BYREF )>
 *  $ARGUMENTS$
 *      <n>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      ISARRAY()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *    Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      ISARRAY( n ) --> <see ( hb_param( n, HB_IT_ARRAY ) != NULL )>
 *  $ARGUMENTS$
 *      <n>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      ISOBJECT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *    Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      ISOBJECT( n ) --> <see ( ISARRAY( n ) && hb_param( n, HB_IT_ARRAY )->asArray.value->uiClass != 0 )>
 *  $ARGUMENTS$
 *      <n>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      ISBLOCK()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *    Extend
 *  $ONELINER$
 *      Not available in CA-Cl*pper.
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      ISBLOCK( n ) --> <see ( hb_param( n, HB_IT_BLOCK ) != NULL )>
 *  $ARGUMENTS$
 *      <n>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      ISPOINTER()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *    Extend
 *  $ONELINER$
 *      Not available in CA-Cl*pper.
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      ISPOINTER( n ) --> <see ( hb_param( n, HB_IT_POINTER ) != NULL )>
 *  $ARGUMENTS$
 *      <n>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      HB_ISSPACE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *    Extend
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapi.h>
 *      HB_ISSPACE( c ) --> <see ( ( c ) == ' ' || ( c ) == HB_CHAR_HT || ( c ) == HB_CHAR_LF || ( c ) == HB_CHAR_CR )>
 *  $ARGUMENTS$
 *      <c>
 *  $RETURNS$
 *      <bResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapi.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */
