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

/*
 * The following parts are Copyright of the individual authors.
 * www - http://www.harbour-project.org
 *
 * Copyright 1999 {list of individual authors and e-mail addresses}
 *   Header file for the API
 *
 * See COPYING for licensing terms.
 *
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_rddInsertAreaNode()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapirdd.h>
 *      hb_rddInsertAreaNode( char *szDriver ) --> ( USHORT )usResult
 *  $ARGUMENTS$
 *      <*szDriver>
 *  $RETURNS$
 *      <usResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is rdd, nulsys, dbfntx, dbfcdx
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_rddGetCurrentWorkAreaNumber()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapirdd.h>
 *      hb_rddGetCurrentWorkAreaNumber( void ) --> ( int )iResult
 *  $ARGUMENTS$
 *
 *  $RETURNS$
 *      <iResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is rdd, nulsys, dbfntx, dbfcdx
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_rddGetCurrentWorkAreaPointer()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapirdd.h>
 *      hb_rddGetCurrentWorkAreaPointer( void ) --> ( void * )pResult
 *  $ARGUMENTS$
 *
 *  $RETURNS$
 *      <pResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is rdd, nulsys, dbfntx, dbfcdx
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_rddSelectWorkAreaAlias()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapirdd.h>
 *      hb_rddSelectWorkAreaAlias( char * szAlias ) --> ( HB_ERRCODE )hResult
 *  $ARGUMENTS$
 *      <szAlias>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is rdd, nulsys, dbfntx, dbfcdx
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_rddSelectWorkAreaNumber()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapirdd.h>
 *      hb_rddSelectWorkAreaNumber( int iArea ) --> ( HB_ERRCODE )hResult
 *  $ARGUMENTS$
 *      <iArea>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is rdd, nulsys, dbfntx, dbfcdx
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_rddSelectWorkAreaSymbol()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapirdd.h>
 *      hb_rddSelectWorkAreaSymbol( PHB_SYMB pSymAlias ) --> ( HB_ERRCODE )hResult
 *  $ARGUMENTS$
 *      <pSymAlias>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is rdd, nulsys, dbfntx, dbfcdx
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_rddGetFieldValue()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapirdd.h>
 *      hb_rddGetFieldValue( HB_ITEM_PTR pItem, PHB_SYMB pFieldSymbol ) --> ( HB_ERRCODE )hResult
 *  $ARGUMENTS$
 *      <pItem>
 *
 *      <pFieldSymbol>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is rdd, nulsys, dbfntx, dbfcdx
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_rddPutFieldValue()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapirdd.h>
 *      hb_rddPutFieldValue( HB_ITEM_PTR pItem, PHB_SYMB pFieldSymbol ) --> ( HB_ERRCODE )hResult
 *  $ARGUMENTS$
 *      <pItem>
 *
 *      <pFieldSymbol>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is rdd, nulsys, dbfntx, dbfcdx
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_rddFieldGet()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapirdd.h>
 *      hb_rddFieldGet( HB_ITEM_PTR pItem, PHB_SYMB pFieldSymbol ) --> ( HB_ERRCODE )hResult
 *  $ARGUMENTS$
 *      <pItem>
 *
 *      <pFieldSymbol>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is rdd, nulsys, dbfntx, dbfcdx
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_rddFieldPut()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapirdd.h>
 *      hb_rddFieldPut( HB_ITEM_PTR pItem, PHB_SYMB pFieldSymbol ) --> ( HB_ERRCODE )hResult
 *  $ARGUMENTS$
 *      <pItem>
 *
 *      <pFieldSymbol>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is rdd, nulsys, dbfntx, dbfcdx
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Procedure
 *  $NAME$
 *      hb_rddShutDown()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapirdd.h>
 *      hb_rddShutDown( void )
 *  $ARGUMENTS$
 *
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is rdd, nulsys, dbfntx, dbfcdx
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_rddInherit()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapirdd.h>
 *      hb_rddInherit( PRDDFUNCS pTable, PRDDFUNCS pSubTable, PRDDFUNCS pSuperTable, BYTE * szDrvName ) --> ( HB_ERRCODE )hResult
 *  $ARGUMENTS$
 *      <pTable>
 *
 *      <pSubTable>
 *
 *      <pSuperTable>
 *
 *      <szDrvName>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is rdd, nulsys, dbfntx, dbfcdx
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_rddDisinherit()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapirdd.h>
 *      hb_rddDisinherit( BYTE * drvName ) --> ( HB_ERRCODE )hResult
 *  $ARGUMENTS$
 *      <drvName>
 *  $RETURNS$
 *      <hResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is rdd, nulsys, dbfntx, dbfcdx
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_rddExtendType()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapirdd.h>
 *      hb_rddExtendType( USHORT fieldType ) --> ( USHORT )usResult
 *  $ARGUMENTS$
 *      <fieldType>
 *  $RETURNS$
 *      <usResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is rdd, nulsys, dbfntx, dbfcdx
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      hb_rddFieldType()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype
 *
 *      #include <hbapirdd.h>
 *      hb_rddFieldType( USHORT extendType ) --> ( USHORT )usResult
 *  $ARGUMENTS$
 *      <extendType>
 *  $RETURNS$
 *      <usResult>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Library is rdd, nulsys, dbfntx, dbfcdx
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_BOF()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_BOF( w, sp ) --> <see ( ( *( w )->lprfsHost->bof )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->bof )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_EOF()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_EOF( w, sp ) --> <see ( ( *( w )->lprfsHost->eof )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->eof )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_FOUND()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_FOUND( w, sp ) --> <see ( ( *( w )->lprfsHost->found )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->found )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_GOTO()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_GOTO( w, l ) --> <see ( ( *( w )->lprfsHost->go )( w, l ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <l>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->go )( w, l ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_GOTOID()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_GOTOID( w, sp ) --> <see ( ( *( w )->lprfsHost->goToId )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->goToId )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_GOBOTTOM()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_GOBOTTOM( w ) --> <see ( ( *( w )->lprfsHost->goBottom )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->goBottom )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_GOTOP()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_GOTOP( w ) --> <see ( ( *( w )->lprfsHost->goTop )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->goTop )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_SEEK()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_SEEK( w, i1, v, i2 ) --> <see ( ( *( w )->lprfsHost->seek )( w, i1, v, i2 ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i1>
 *
 *      <v>
 *
 *      <i2>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->seek )( w, i1, v, i2 ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_SKIP()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_SKIP( w, l ) --> <see ( ( *( w )->lprfsHost->skip )( w, l ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <l>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->skip )( w, l ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_SKIPFILTER()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_SKIPFILTER( w, l ) --> <see ( ( *( w )->lprfsHost->skipFilter )( w, l ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <l>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->skipFilter )( w, l ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_SKIPRAW()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_SKIPRAW( w, l ) --> <see ( ( *( w )->lprfsHost->skipRaw )( w, l ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <l>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->skipRaw )( w, l ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ADDFIELD()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ADDFIELD( w, ip ) --> <see ( ( *( w )->lprfsHost->addField )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->addField )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_APPEND()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_APPEND( w, l ) --> <see ( ( *( w )->lprfsHost->append )( w, l ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <l>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->append )( w, l ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_CREATEFIELDS()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_CREATEFIELDS( w, v ) --> <see ( ( *( w )->lprfsHost->createFields )( w, v ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <v>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->createFields )( w, v ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_DELETE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_DELETE( w ) --> <see ( ( *( w )->lprfsHost->deleterec )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->deleterec )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_DELETED()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_DELETED( w, sp ) --> <see ( ( *( w )->lprfsHost->deleted )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->deleted )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_FIELDCOUNT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_FIELDCOUNT( w, sp ) --> <see ( ( *( w )->lprfsHost->fieldCount )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->fieldCount )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_FIELDDISPLAY()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_FIELDDISPLAY( w, sp ) --> <see ( ( *( w )->lprfsHost->fieldDisplay )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->fieldDisplay )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_FIELDINFO()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_FIELDINFO( w, s1, s2, v ) --> <see ( ( *( w )->lprfsHost->fieldInfo )( w, s1, s2, v ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <s1>
 *
 *      <s2>
 *
 *      <v>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->fieldInfo )( w, s1, s2, v ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_FIELDNAME()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_FIELDNAME( w, i, bp ) --> <see ( ( *( w )->lprfsHost->fieldName )( w, i, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->fieldName )( w, i, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_FLUSH()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_FLUSH( w ) --> <see ( ( *( w )->lprfsHost->flush )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->flush )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_GETREC()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_GETREC( w, bpp ) --> <see ( ( *( w )->lprfsHost->getRec )( w, bpp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <bpp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->getRec )( w, bpp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_GETVALUE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_GETVALUE( w, i, v ) --> <see ( ( *( w )->lprfsHost->getValue )( w, i, v ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <v>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->getValue )( w, i, v ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_GETVARLEN()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_GETVARLEN( w, i, lp ) --> <see ( ( *( w )->lprfsHost->getVarLen )( w, i, lp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <lp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->getVarLen )( w, i, lp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_GOCOLD()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_GOCOLD( w ) --> <see ( ( *( w )->lprfsHost->goCold )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->goCold )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_GOHOT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_GOHOT( w ) --> <see ( ( *( w )->lprfsHost->goHot )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->goHot )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_PUTVALUE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_PUTVALUE( w, i, v ) --> <see ( ( *( w )->lprfsHost->putValue )( w, i, v ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <v>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->putValue )( w, i, v ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_PUTREC()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_PUTREC( w, bp ) --> <see ( ( *( w )->lprfsHost->putRec )( w, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->putRec )( w, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_RECALL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_RECALL( w ) --> <see ( ( *( w )->lprfsHost->recall )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->recall )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_RECCOUNT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_RECCOUNT( w, sp ) --> <see ( ( *( w )->lprfsHost->reccount )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->reccount )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_RECINFO()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_RECINFO( w, v1, i, v2 ) --> <see ( ( *( w )->lprfsHost->recInfo )( w, v1, i, v2 ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <v1>
 *
 *      <i>
 *
 *      <v2>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->recInfo )( w, v1, i, v2 ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_RECNO()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_RECNO( w, i ) --> <see ( ( *( w )->lprfsHost->recno )( w, i ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->recno )( w, i ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_SETFIELDEXTENT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_SETFIELDEXTENT( w, s ) --> <see ( ( *( w )->lprfsHost->setFieldExtent )( w, s ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <s>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->setFieldExtent )( w, s ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ALIAS()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ALIAS( w, bp ) --> <see ( ( *( w )->lprfsHost->alias )( w, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->alias )( w, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_CLOSE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_CLOSE( w ) --> <see ( ( *( w )->lprfsHost->close )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->close )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_CREATE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_CREATE( w, ip ) --> <see ( ( *( w )->lprfsHost->create )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->create )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_INFO()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_INFO( w, i, g ) --> <see ( ( *( w )->lprfsHost->info )( w, i, g ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <g>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->info )( w, i, g ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_NEW()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_NEW( w ) --> <see ( ( *( w )->lprfsHost->newarea )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->newarea )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_OPEN()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_OPEN( w, ip ) --> <see ( ( *( w )->lprfsHost->open )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->open )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_RELEASE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_RELEASE( w ) --> <see ( ( *( w )->lprfsHost->release )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->release )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_STRUCTSIZE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_STRUCTSIZE( w, sp ) --> <see ( ( *( w )->lprfsHost->structSize )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->structSize )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_SYSNAME()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_SYSNAME( w, bp ) --> <see ( ( *( w )->lprfsHost->sysName )( w, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->sysName )( w, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_DBEVAL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_DBEVAL( w, ip ) --> <see ( ( *( w )->lprfsHost->dbEval )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->dbEval )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_PACK()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_PACK( w ) --> <see ( ( *( w )->lprfsHost->pack )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->pack )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_PACKREC()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_PACKREC( w, l, sp ) --> <see ( ( *( w )->lprfsHost->packRec )( w, l, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <l>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->packRec )( w, l, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_SORT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_SORT( w, ip ) --> <see ( ( *( w )->lprfsHost->sort )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->sort )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_TRANS()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_TRANS( w, ip ) --> <see ( ( *( w )->lprfsHost->trans )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->trans )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_TRANSREC()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_TRANSREC( w, ip ) --> <see ( ( *( w )->lprfsHost->transRec )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->transRec )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ZAP()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ZAP( w ) --> <see ( ( *( w )->lprfsHost->zap )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->zap )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_CHILDEND()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_CHILDEND( w, ip ) --> <see ( ( *( w )->lprfsHost->childEnd )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->childEnd )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_CHILDSTART()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_CHILDSTART( w, ip ) --> <see ( ( *( w )->lprfsHost->childStart )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->childStart )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_CHILDSYNC()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_CHILDSYNC( w, ip ) --> <see ( ( *( w )->lprfsHost->childSync )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->childSync )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_SYNCCHILDREN()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_SYNCCHILDREN( w ) --> <see ( ( *( w )->lprfsHost->syncChildren )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->syncChildren )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_CLEARREL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_CLEARREL( w ) --> <see ( ( *( w )->lprfsHost->clearRel )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->clearRel )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_FORCEREL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_FORCEREL( w ) --> <see ( ( *( w )->lprfsHost->forceRel )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->forceRel )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_RELAREA()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_RELAREA( w, s, sp ) --> <see ( ( *( w )->lprfsHost->relArea )( w, s, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <s>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->relArea )( w, s, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_RELEVAL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_RELEVAL( w, ip ) --> <see ( ( *( w )->lprfsHost->relEval )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->relEval )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_RELTEXT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_RELTEXT( w, s, bp ) --> <see ( ( *( w )->lprfsHost->relText )( w, s, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <s>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->relText )( w, s, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_SETREL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_SETREL( w, ip ) --> <see ( ( *( w )->lprfsHost->setRel )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->setRel )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ORDLSTADD()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ORDLSTADD( w, lp ) --> <see ( ( *( w )->lprfsHost->orderListAdd )( w, lp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <lp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->orderListAdd )( w, lp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ORDLSTDELETE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ORDLSTDELETE( w, lp ) --> <see ( ( *( w )->lprfsHost->orderListDelete )( w, lp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <lp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->orderListDelete )( w, lp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ORDLSTFOCUS()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ORDLSTFOCUS( w, lp ) --> <see ( ( *( w )->lprfsHost->orderListFocus )( w, lp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <lp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->orderListFocus )( w, lp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ORDLSTREBUILD()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ORDLSTREBUILD( w ) --> <see ( ( *( w )->lprfsHost->orderListRebuild )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->orderListRebuild )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ORDLSTCLEAR()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ORDLSTCLEAR( w ) --> <see ( ( *( w )->lprfsHost->orderListClear )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->orderListClear )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ORDSETCOND()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ORDSETCOND( w, ip ) --> <see ( ( *( w )->lprfsHost->orderCondition )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->orderCondition )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ORDCREATE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ORDCREATE( w, ip ) --> <see ( ( *( w )->lprfsHost->orderCreate )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->orderCreate )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ORDDESTROY()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ORDDESTROY( w, p ) --> <see ( ( *( w )->lprfsHost->orderDestroy )( w, p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->orderDestroy )( w, p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ORDINFO()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ORDINFO( w, i, p ) --> <see ( ( *( w )->lprfsHost->orderInfo )( w, i, p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->orderInfo )( w, i, p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ORDEXPR()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ORDEXPR( w, p ) --> <see ( ( *( w )->lprfsHost->orderInfo )( w, DBOI_EXPRESSION, p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->orderInfo )( w, DBOI_EXPRESSION, p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ORDCOND()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ORDCOND( w, p ) --> <see ( ( *( w )->lprfsHost->orderInfo )( w, DBOI_CONDITION,  p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->orderInfo )( w, DBOI_CONDITION,  p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ORDRECNO()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ORDRECNO( w, p ) --> <see ( ( *( w )->lprfsHost->orderInfo )( w, DBOI_RECNO,      p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->orderInfo )( w, DBOI_RECNO,      p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ORDPOS()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ORDPOS( w, p ) --> <see ( ( *( w )->lprfsHost->orderInfo )( w, DBOI_POSITION,   p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->orderInfo )( w, DBOI_POSITION,   p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ORDNUMBER()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ORDNUMBER( w, p ) --> <see ( ( *( w )->lprfsHost->orderInfo )( w, DBOI_NUMBER,     p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->orderInfo )( w, DBOI_NUMBER,     p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ORDNAME()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ORDNAME( w, p ) --> <see ( ( *( w )->lprfsHost->orderInfo )( w, DBOI_NAME,       p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->orderInfo )( w, DBOI_NAME,       p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ORDBAGNAME()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ORDBAGNAME( w, p ) --> <see ( ( *( w )->lprfsHost->orderInfo )( w, DBOI_BAGNAME,    p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->orderInfo )( w, DBOI_BAGNAME,    p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ORDBAGEXT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ORDBAGEXT( w,  p ) --> <see ( ( *( w )->lprfsHost->orderInfo )( w, DBOI_BAGEXT,     p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->orderInfo )( w, DBOI_BAGEXT,     p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_CLEARFILTER()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_CLEARFILTER( w ) --> <see ( ( *( w )->lprfsHost->clearFilter )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->clearFilter )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_CLEARLOCATE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_CLEARLOCATE( w ) --> <see ( ( *( w )->lprfsHost->clearLocate )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->clearLocate )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_CLEARSCOPE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_CLEARSCOPE( w ) --> <see ( ( *( w )->lprfsHost->clearScope )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->clearScope )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_COUNTSCOPE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_COUNTSCOPE( w, ip, lp ) --> <see ( ( *( w )->lprfsHost->countScope )( w, ip, lp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *
 *      <lp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->countScope )( w, ip, lp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_FILTERTEXT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_FILTERTEXT( w, bp ) --> <see ( ( *( w )->lprfsHost->filterText )( w, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->filterText )( w, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_SCOPEINFO()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_SCOPEINFO( w, i, v ) --> <see ( ( *( w )->lprfsHost->scopeInfo )( w, i, v ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <v>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->scopeInfo )( w, i, v ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_SETFILTER()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_SETFILTER( w, ip ) --> <see ( ( *( w )->lprfsHost->setFilter )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->setFilter )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_SETLOCATE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_SETLOCATE( w, ip ) --> <see ( ( *( w )->lprfsHost->setLocate )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->setLocate )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_SETSCOPE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_SETSCOPE( w, ip ) --> <see ( ( *( w )->lprfsHost->setScope )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->setScope )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_SKIPSCOPE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_SKIPSCOPE( w, bp, l ) --> <see ( ( *( w )->lprfsHost->skipScope )( w, bp, l ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <bp>
 *
 *      <l>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->skipScope )( w, bp, l ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_COMPILE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_COMPILE( w, bp ) --> <see ( ( *( w )->lprfsHost->compile )( w, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->compile )( w, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_ERROR()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_ERROR( w, ip ) --> <see ( ( *( w )->lprfsHost->error )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->error )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_EVALBLOCK()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_EVALBLOCK( w, v ) --> <see ( ( *( w )->lprfsHost->evalBlock )( w, v ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <v>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->evalBlock )( w, v ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_GETLOCKS()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_GETLOCKS( w, g ) --> <see ( ( *( w )->lprfsHost->info )( w, DBI_GETLOCKARRAY, g ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <g>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->info )( w, DBI_GETLOCKARRAY, g ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_RAWLOCK()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_RAWLOCK( w, i, l ) --> <see ( ( *( w )->lprfsHost->rawlock )( w, i, l ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <l>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->rawlock )( w, i, l ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_LOCK()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_LOCK( w, sp ) --> <see ( ( *( w )->lprfsHost->lock )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->lock )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_UNLOCK()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_UNLOCK( w, l ) --> <see ( ( *( w )->lprfsHost->unlock )( w, l ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <l>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->unlock )( w, l ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_CLOSEMEMFILE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_CLOSEMEMFILE( w ) --> <see ( ( *( w )->lprfsHost->closeMemFile )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->closeMemFile )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_CREATEMEMFILE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_CREATEMEMFILE( w, bp ) --> <see ( ( *( w )->lprfsHost->createMemFile )( w, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->createMemFile )( w, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_GETVALUEFILE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_GETVALUEFILE( w, i, bp ) --> <see ( ( *( w )->lprfsHost->getValueFile )( w, i, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->getValueFile )( w, i, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_OPENMEMFILE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_OPENMEMFILE( w, bp ) --> <see ( ( *( w )->lprfsHost->openMemFile )( w, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->openMemFile )( w, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_PUTVALUEFILE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_PUTVALUEFILE( w, i, bp ) --> <see ( ( *( w )->lprfsHost->putValueFile )( w, i, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->putValueFile )( w, i, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_READDBHEADER()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_READDBHEADER( w ) --> <see ( ( *( w )->lprfsHost->readDBHeader )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->readDBHeader )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_WRITEDBHEADER()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_WRITEDBHEADER( w ) --> <see ( ( *( w )->lprfsHost->writeDBHeader )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->writeDBHeader )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_RECSIZE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_RECSIZE( w, lp ) --> <see ( ( *( w )->lprfsHost->info )( w, DBI_GETRECSIZE, lp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <lp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->info )( w, DBI_GETRECSIZE, lp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_HEADERSIZE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_HEADERSIZE( w, fp ) --> <see ( ( *( w )->lprfsHost->info )( w, DBI_GETHEADERSIZE, fp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <fp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->info )( w, DBI_GETHEADERSIZE, fp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_LUPDATE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_LUPDATE( w, fp ) --> <see ( ( *( w )->lprfsHost->info )( w, DBI_LASTUPDATE, fp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <fp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->info )( w, DBI_LASTUPDATE, fp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_SETDELIM()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_SETDELIM( w, fp ) --> <see ( ( *( w )->lprfsHost->info )( w, DBI_SETDELIMITER, fp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <fp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->info )( w, DBI_SETDELIMITER, fp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_GETDELIM()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_GETDELIM( w, fp ) --> <see ( ( *( w )->lprfsHost->info )( w, DBI_GETDELIMITER, fp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <fp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->info )( w, DBI_GETDELIMITER, fp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SELF_TABLEEXT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SELF_TABLEEXT( w, fp ) --> <see ( ( *( w )->lprfsHost->info )( w, DBI_TABLEEXT, fp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <fp>
 *  $RETURNS$
 *      <see ( ( *( w )->lprfsHost->info )( w, DBI_TABLEEXT, fp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_BOF()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_BOF( w, sp ) --> <see ( ( *( SUPERTABLE )->bof )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->bof )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_EOF()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_EOF( w, sp ) --> <see ( ( *( SUPERTABLE )->eof )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->eof )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_FOUND()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_FOUND( w, sp ) --> <see ( ( *( SUPERTABLE )->found )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->found )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_GOTO()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_GOTO( w, l ) --> <see ( ( *( SUPERTABLE )->go )( w, l ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <l>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->go )( w, l ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_GOTOID()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_GOTOID( w, sp ) --> <see ( ( *( SUPERTABLE )->goToId )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->goToId )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_GOBOTTOM()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_GOBOTTOM( w ) --> <see ( ( *( SUPERTABLE )->goBottom )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->goBottom )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_GOTOP()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_GOTOP( w ) --> <see ( ( *( SUPERTABLE )->goTop )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->goTop )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_SEEK()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_SEEK( w, i1, v, i2 ) --> <see ( ( *( SUPERTABLE )->seek )( w, i1, v, i2 ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i1>
 *
 *      <v>
 *
 *      <i2>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->seek )( w, i1, v, i2 ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_SKIP()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_SKIP( w, l ) --> <see ( ( *( SUPERTABLE )->skip )( w, l ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <l>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->skip )( w, l ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_SKIPFILTER()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_SKIPFILTER( w, l ) --> <see ( ( *( SUPERTABLE )->skipFilter )( w, l ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <l>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->skipFilter )( w, l ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_SKIPRAW()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_SKIPRAW( w, l ) --> <see ( ( *( SUPERTABLE )->skipRaw )( w, l ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <l>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->skipRaw )( w, l ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ADDFIELD()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ADDFIELD( w, ip ) --> <see ( ( *( SUPERTABLE )->addField )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->addField )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_APPEND()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_APPEND( w, l ) --> <see ( ( *( SUPERTABLE )->append )( w, l ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <l>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->append )( w, l ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_CREATEFIELDS()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_CREATEFIELDS( w, v ) --> <see ( ( *( SUPERTABLE )->createFields )( w, v ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <v>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->createFields )( w, v ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_DELETE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_DELETE( w ) --> <see ( ( *( SUPERTABLE )->deleterec )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->deleterec )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_DELETED()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_DELETED( w, sp ) --> <see ( ( *( SUPERTABLE )->deleted )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->deleted )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_FIELDCOUNT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_FIELDCOUNT( w, sp ) --> <see ( ( *( SUPERTABLE )->fieldCount )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->fieldCount )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_FIELDDISPLAY()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_FIELDDISPLAY( w, sp ) --> <see ( ( *( SUPERTABLE )->fieldDisplay )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->fieldDisplay )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_FIELDINFO()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_FIELDINFO( w, s1, s2, v ) --> <see ( ( *( SUPERTABLE )->fieldInfo )( w, s1, s2, v ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <s1>
 *
 *      <s2>
 *
 *      <v>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->fieldInfo )( w, s1, s2, v ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_FIELDNAME()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_FIELDNAME( w, i, bp ) --> <see ( ( *( SUPERTABLE )->fieldName )( w, i, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->fieldName )( w, i, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_FLUSH()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_FLUSH( w ) --> <see ( ( *( SUPERTABLE )->flush )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->flush )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_GETREC()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_GETREC( w, bpp ) --> <see ( ( *( SUPERTABLE )->getRec )( w, bpp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <bpp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->getRec )( w, bpp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_GETVALUE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_GETVALUE( w, i, v ) --> <see ( ( *( SUPERTABLE )->getValue )( w, i, v ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <v>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->getValue )( w, i, v ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_GETVARLEN()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_GETVARLEN( w, i, lp ) --> <see ( ( *( SUPERTABLE )->getVarLen )( w, i, lp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <lp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->getVarLen )( w, i, lp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_GOCOLD()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_GOCOLD( w ) --> <see ( ( *( SUPERTABLE )->goCold )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->goCold )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_GOHOT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_GOHOT( w ) --> <see ( ( *( SUPERTABLE )->goHot )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->goHot )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_PUTVALUE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_PUTVALUE( w, i, v ) --> <see ( ( *( SUPERTABLE )->putValue )( w, i, v ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <v>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->putValue )( w, i, v ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_PUTREC()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_PUTREC( w, bp ) --> <see ( ( *( SUPERTABLE )->putRec )( w, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->putRec )( w, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_RECALL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_RECALL( w ) --> <see ( ( *( SUPERTABLE )->recall )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->recall )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_RECCOUNT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_RECCOUNT( w, sp ) --> <see ( ( *( SUPERTABLE )->reccount )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->reccount )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_RECINFO()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_RECINFO( w, v1, i, v2 ) --> <see ( ( *( SUPERTABLE )->recInfo )( w, v1, i, v2 ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <v1>
 *
 *      <i>
 *
 *      <v2>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->recInfo )( w, v1, i, v2 ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_RECNO()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_RECNO( w, sp ) --> <see ( ( *( SUPERTABLE )->recno )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->recno )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_SETFIELDEXTENT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_SETFIELDEXTENT( w, s ) --> <see ( ( *( SUPERTABLE )->setFieldExtent )( w, s ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <s>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->setFieldExtent )( w, s ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ALIAS()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ALIAS( w, bp ) --> <see ( ( *( SUPERTABLE )->alias )( w, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->alias )( w, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_CLOSE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_CLOSE( w ) --> <see ( ( *( SUPERTABLE )->close )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->close )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_CREATE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_CREATE( w, ip ) --> <see ( ( *( SUPERTABLE )->create )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->create )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_INFO()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_INFO( w, i, g ) --> <see ( ( *( SUPERTABLE )->info )( w, i, g ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <g>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->info )( w, i, g ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_NEW()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_NEW( w ) --> <see ( ( *( SUPERTABLE )->newarea )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->newarea )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_OPEN()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_OPEN( w, ip ) --> <see ( ( *( SUPERTABLE )->open )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->open )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_RELEASE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_RELEASE( w ) --> <see ( ( *( SUPERTABLE )->release )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->release )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_STRUCTSIZE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_STRUCTSIZE( w, sp ) --> <see ( ( *( SUPERTABLE )->structSize )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->structSize )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_SYSNAME()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_SYSNAME( w, bp ) --> <see ( ( *( SUPERTABLE )->sysName )( w, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->sysName )( w, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_DBEVAL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_DBEVAL( w, ip ) --> <see ( ( *( SUPERTABLE )->dbEval )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->dbEval )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_PACK()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_PACK( w ) --> <see ( ( *( SUPERTABLE )->pack )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->pack )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_PACKREC()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_PACKREC( w, l, sp ) --> <see ( ( *( SUPERTABLE )->packRec )( w, l, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <l>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->packRec )( w, l, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_SORT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_SORT( w, ip ) --> <see ( ( *( SUPERTABLE )->sort )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->sort )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_TRANS()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_TRANS( w, ip ) --> <see ( ( *( SUPERTABLE )->trans )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->trans )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_TRANSREC()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_TRANSREC( w, ip ) --> <see ( ( *( SUPERTABLE )->transRec )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->transRec )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ZAP()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ZAP( w ) --> <see ( ( *( SUPERTABLE )->zap )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->zap )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_CHILDEND()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_CHILDEND( w, ip ) --> <see ( ( *( SUPERTABLE )->childEnd )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->childEnd )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_CHILDSTART()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_CHILDSTART( w, ip ) --> <see ( ( *( SUPERTABLE )->childStart )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->childStart )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_CHILDSYNC()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_CHILDSYNC( w, ip ) --> <see ( ( *( SUPERTABLE )->childSync )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->childSync )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_SYNCCHILDREN()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_SYNCCHILDREN( w ) --> <see ( ( *( SUPERTABLE )->syncChildren )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->syncChildren )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_CLEARREL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_CLEARREL( w ) --> <see ( ( *( SUPERTABLE )->clearRel )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->clearRel )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_FORCEREL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_FORCEREL( w ) --> <see ( ( *( SUPERTABLE )->forceRel )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->forceRel )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_RELAREA()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_RELAREA( w, s, sp ) --> <see ( ( *( SUPERTABLE )->relArea )( w, s, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <s>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->relArea )( w, s, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_RELEVAL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_RELEVAL( w, ip ) --> <see ( ( *( SUPERTABLE )->relEval )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->relEval )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_RELTEXT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_RELTEXT( w, s, bp ) --> <see ( ( *( SUPERTABLE )->relText )( w, s, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <s>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->relText )( w, s, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_SETREL()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_SETREL( w, ip ) --> <see ( ( *( SUPERTABLE )->setRel )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->setRel )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ORDLSTADD()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ORDLSTADD( w, lp ) --> <see ( ( *( SUPERTABLE )->orderListAdd )( w, lp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <lp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->orderListAdd )( w, lp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ORDLSTDELETE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ORDLSTDELETE( w, lp ) --> <see ( ( *( SUPERTABLE )->orderListDelete )( w, lp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <lp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->orderListDelete )( w, lp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ORDLSTFOCUS()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ORDLSTFOCUS( w, lp ) --> <see ( ( *( SUPERTABLE )->orderListFocus )( w, lp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <lp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->orderListFocus )( w, lp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ORDLSTREBUILD()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ORDLSTREBUILD( w ) --> <see ( ( *( SUPERTABLE )->orderListRebuild )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->orderListRebuild )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ORDLSTCLEAR()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ORDLSTCLEAR( w ) --> <see ( ( *( SUPERTABLE )->orderListClear )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->orderListClear )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ORDSETCOND()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ORDSETCOND( w, ip ) --> <see ( ( *( SUPERTABLE )->orderCondition )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->orderCondition )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ORDCREATE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ORDCREATE( w, ip ) --> <see ( ( *( SUPERTABLE )->orderCreate )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->orderCreate )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ORDDELETE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ORDDELETE( w, ip ) --> <see ( ( *( SUPERTABLE )->orderDelete )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->orderDelete )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ORDINFO()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ORDINFO( w, i, p ) --> <see ( ( *( SUPERTABLE )->orderInfo )( w, i, p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->orderInfo )( w, i, p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ORDEXPR()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ORDEXPR( w, p ) --> <see ( ( *( SUPERTABLE )->orderInfo )( w, DBOI_EXPRESSION, p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->orderInfo )( w, DBOI_EXPRESSION, p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ORDCOND()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ORDCOND( w, p ) --> <see ( ( *( SUPERTABLE )->orderInfo )( w, DBOI_CONDITION,  p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->orderInfo )( w, DBOI_CONDITION,  p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ORDRECNO()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ORDRECNO( w, p ) --> <see ( ( *( SUPERTABLE )->orderInfo )( w, DBOI_RECNO,      p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->orderInfo )( w, DBOI_RECNO,      p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ORDPOS()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ORDPOS( w, p ) --> <see ( ( *( SUPERTABLE )->orderInfo )( w, DBOI_POSITION,   p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->orderInfo )( w, DBOI_POSITION,   p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ORDNUMBER()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ORDNUMBER( w, p ) --> <see ( ( *( SUPERTABLE )->orderInfo )( w, DBOI_NUMBER,     p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->orderInfo )( w, DBOI_NUMBER,     p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ORDNAME()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ORDNAME( w, p ) --> <see ( ( *( SUPERTABLE )->orderInfo )( w, DBOI_NAME,       p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->orderInfo )( w, DBOI_NAME,       p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ORDBAGNAME()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ORDBAGNAME( w, p ) --> <see ( ( *( SUPERTABLE )->orderInfo )( w, DBOI_BAGNAME,    p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->orderInfo )( w, DBOI_BAGNAME,    p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ORDBAGEXT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ORDBAGEXT( w,  p ) --> <see ( ( *( SUPERTABLE )->orderInfo )( w, DBOI_BAGEXT,     p ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <p>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->orderInfo )( w, DBOI_BAGEXT,     p ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_CLEARFILTER()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_CLEARFILTER( w ) --> <see ( ( *( SUPERTABLE )->clearFilter )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->clearFilter )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_CLEARLOCATE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_CLEARLOCATE( w ) --> <see ( ( *( SUPERTABLE )->clearLocate )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->clearLocate )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_CLEARSCOPE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_CLEARSCOPE( w ) --> <see ( ( *( SUPERTABLE )->clearScope )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->clearScope )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_COUNTSCOPE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_COUNTSCOPE( w, ip, lp ) --> <see ( ( *( SUPERTABLE )->countScope )( w, ip, lp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *
 *      <lp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->countScope )( w, ip, lp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_FILTERTEXT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_FILTERTEXT( w, bp ) --> <see ( ( *( SUPERTABLE )->filterText )( w, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->filterText )( w, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_SCOPEINFO()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_SCOPEINFO( w, i, v ) --> <see ( ( *( SUPERTABLE )->scopeInfo )( w, i, v ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <v>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->scopeInfo )( w, i, v ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_SETFILTER()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_SETFILTER( w, ip ) --> <see ( ( *( SUPERTABLE )->setFilter )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->setFilter )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_SETLOCATE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_SETLOCATE( w, ip ) --> <see ( ( *( SUPERTABLE )->setLocate )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->setLocate )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_SETSCOPE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_SETSCOPE( w, ip ) --> <see ( ( *( SUPERTABLE )->setScope )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->setScope )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_SKIPSCOPE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_SKIPSCOPE( w, bp, l ) --> <see ( ( *( SUPERTABLE )->skipScope )( w, bp, l ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <bp>
 *
 *      <l>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->skipScope )( w, bp, l ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_COMPILE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_COMPILE( w, bp ) --> <see ( ( *( SUPERTABLE )->compile )( w, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->compile )( w, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_ERROR()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_ERROR( w, ip ) --> <see ( ( *( SUPERTABLE )->error )( w, ip ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <ip>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->error )( w, ip ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_EVALBLOCK()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_EVALBLOCK( w, v ) --> <see ( ( *( SUPERTABLE )->evalBlock )( w, v ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <v>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->evalBlock )( w, v ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_GETLOCKS()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_GETLOCKS( w, g ) --> <see ( ( *( SUPERTABLE )->info )( w, DBI_GETLOCKARRAY, g ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <g>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->info )( w, DBI_GETLOCKARRAY, g ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_RAWLOCK()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_RAWLOCK( w, i, l ) --> <see ( ( *( SUPERTABLE )->rawlock )( w, i, l ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <l>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->rawlock )( w, i, l ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_LOCK()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_LOCK( w, sp ) --> <see ( ( *( SUPERTABLE )->lock )( w, sp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <sp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->lock )( w, sp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_UNLOCK()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_UNLOCK( w ) --> <see ( ( *( SUPERTABLE )->unlock )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->unlock )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_CLOSEMEMFILE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_CLOSEMEMFILE( w ) --> <see ( ( *( SUPERTABLE )->closeMemFile )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->closeMemFile )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_CREATEMEMFILE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_CREATEMEMFILE( w, bp ) --> <see ( ( *( SUPERTABLE )->createMemFile )( w, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->createMemFile )( w, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_GETVALUEFILE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_GETVALUEFILE( w, i, bp ) --> <see ( ( *( SUPERTABLE )->getValueFile )( w, i, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->getValueFile )( w, i, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_OPENMEMFILE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_OPENMEMFILE( w, bp ) --> <see ( ( *( SUPERTABLE )->openMemFile )( w, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->openMemFile )( w, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_PUTVALUEFILE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_PUTVALUEFILE( w, i, bp ) --> <see ( ( *( SUPERTABLE )->putValueFile )( w, i, bp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <i>
 *
 *      <bp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->putValueFile )( w, i, bp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_READDBHEADER()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_READDBHEADER( w ) --> <see ( ( *( SUPERTABLE )->readDBHeader )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->readDBHeader )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_WRITEDBHEADER()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_WRITEDBHEADER( w ) --> <see ( ( *( SUPERTABLE )->writeDBHeader )( w ) )>
 *  $ARGUMENTS$
 *      <w>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->writeDBHeader )( w ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_RECSIZE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_RECSIZE( w, lp ) --> <see ( ( *( SUPERTABLE )->info )( w, DBI_GETRECSIZE, lp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <lp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->info )( w, DBI_GETRECSIZE, lp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_HEADERSIZE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_HEADERSIZE( w, fp ) --> <see ( ( *( SUPERTABLE )->info )( w, DBI_GETHEADERSIZE, fp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <fp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->info )( w, DBI_GETHEADERSIZE, fp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_LUPDATE()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_LUPDATE( w, fp ) --> <see ( ( *( SUPERTABLE )->info )( w, DBI_LASTUPDATE, fp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <fp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->info )( w, DBI_LASTUPDATE, fp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_SETDELIM()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_SETDELIM( w, fp ) --> <see ( ( *( SUPERTABLE )->info )( w, DBI_SETDELIMITER, fp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <fp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->info )( w, DBI_SETDELIMITER, fp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_GETDELIM()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_GETDELIM( w, fp ) --> <see ( ( *( SUPERTABLE )->info )( w, DBI_GETDELIMITER, fp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <fp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->info )( w, DBI_GETDELIMITER, fp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */

/*  $DOC$
 *  $TEMPLATE$
 *      Function
 *  $NAME$
 *      SUPER_TABLEEXT()
 *  $CATEGORY$
 *      C level API
 * $SUBCATEGORY$
 *      RDD
 *  $ONELINER$
 *
 *  $SYNTAX$
 *      C Prototype (macro definition)
 *
 *      #include <hbapirdd.h>
 *      SUPER_TABLEEXT( w, fp ) --> <see ( ( *( SUPERTABLE )->info )( w, DBI_TABLEEXT, fp ) )>
 *  $ARGUMENTS$
 *      <w>
 *
 *      <fp>
 *  $RETURNS$
 *      <see ( ( *( SUPERTABLE )->info )( w, DBI_TABLEEXT, fp ) )>
 *  $DESCRIPTION$
 *
 *  $EXAMPLES$
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      NA
 *  $FILES$
 *      Header file is hbapirdd.h
 *  $PLATFORMS$
 *      All
 *  $SEEALSO$
 *
 *  $END$
 */
