/*
 * $Id$
 */

/*
 * The following parts are Copyright of the individual authors.
 * www - http://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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 ? HB_TRUE : HB_FALSE )
   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <pItem>

      <ulLen>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <pArray>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <pArray>

      <pItemValue>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <pArray>

      <ulIndex>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <pArray>

      <ulIndex>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <pArray>

      <ulLen>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <pArray>

      <pResult>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <pArray>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <pArray>

      <ulIndex>

      <pItem>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <pArray>

      <ulIndex>

      <pItem>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <pArray>

      <ulIndex>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <pArray>

      <pValue>

      <pulStart>

      <pulCount>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <pArray>

      <bBlock>

      <pulStart>

      <pulCount>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <pSrcArray>

      <pDstArray>

      <pulStart>

      <pulCount>

      <pulTarget>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <pArray>

      <pulStart>

      <pulCount>

      <pBlock>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <szString>

      <szMask>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <szText>

      <ulLen>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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, HB_BOOL bAnySpace ) --> ( ULONG )ulResult
   $ARGUMENTS$
      <szText>

      <ulLen>

      <bAnySpace>
   $RETURNS$
      <ulResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <szArg>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <pszName>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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( PHB_ITEM pItem )
   $ARGUMENTS$
      <pItem>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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 core
   $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( PHB_ITEM pItem )
   $ARGUMENTS$
      <pItem>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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( PHB_ITEM pSource, HB_BOOL bTrueMemvar ) --> ( HB_HANDLE )hResult
   $ARGUMENTS$
      <pSource>

      <bTrueMemvar>
   $RETURNS$
      <hResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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, PHB_ITEM pItem )
   $ARGUMENTS$
      <pMemvarSymb>

      <pItem>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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( PHB_ITEM pItem, PHB_SYMB pMemvarSymb ) --> ( HB_ERRCODE )hResult
   $ARGUMENTS$
      <pItem>

      <pMemvarSymb>
   $RETURNS$
      <hResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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( PHB_ITEM pItem, PHB_SYMB pMemvarSymb )
   $ARGUMENTS$
      <pItem>

      <pMemvarSymb>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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( PHB_ITEM pItem, PHB_SYMB pMemvarSymb )
   $ARGUMENTS$
      <pItem>

      <pMemvarSymb>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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( HB_BOOL bSetCursor, USHORT usNewCursor ) --> ( USHORT )usResult
   $ARGUMENTS$
      <bSetCursor>

      <usNewCursor>
   $RETURNS$
      <usResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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 core
   $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 core
   $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 core
   $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( PHB_ITEM pItem )
   $ARGUMENTS$
      <pItem>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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( PHB_ITEM pItem )
   $ARGUMENTS$
      <pItem>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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( PHB_ITEM pItem )
   $ARGUMENTS$
      <pItem>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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( PHB_ITEM pItem )
   $ARGUMENTS$
      <pItem>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 ) --> ( HB_BOOL )bResult
   $ARGUMENTS$
      <szString>
   $RETURNS$
      <bResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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( PHB_ITEM pAlias, PHB_ITEM pVar )
   $ARGUMENTS$
      <pAlias>

      <pVar>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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( PHB_ITEM pAlias, PHB_ITEM pVar )
   $ARGUMENTS$
      <pAlias>

      <pVar>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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( PHB_ITEM pItem ) --> ( char * )pszResult
   $ARGUMENTS$
      <pItem>
   $RETURNS$
      <pszResult>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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 core
   $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 core
   $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 core
   $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( PHB_ITEM pItem )
   $ARGUMENTS$
      <pItem>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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( PHB_ITEM pItem )
   $ARGUMENTS$
      <pItem>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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 core
   $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( PHB_ITEM pItem )
   $ARGUMENTS$
      <pItem>
   $DESCRIPTION$

   $EXAMPLES$

   $STATUS$
      R
   $COMPLIANCE$
      NA
   $FILES$
      Library is core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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 core
   $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$
 */
