/*
 * $Id$
 */

/* $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( PHB_ITEM 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( PHB_ITEM 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( PHB_ITEM 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( PHB_ITEM 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$
 */
