761 lines
19 KiB
C
761 lines
19 KiB
C
/*
|
|
* $Id$
|
|
|
|
Copyright(C) 1999 by Bruno Cantero.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published
|
|
by the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
PURPOSE. See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public
|
|
License along with this program; if not, write to:
|
|
|
|
The Free Software Foundation, Inc.,
|
|
675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
You can contact me at: bruno@issnet.net
|
|
*/
|
|
|
|
#include "extend.h"
|
|
#include "init.h"
|
|
#include "itemapi.h"
|
|
#include "errorapi.h"
|
|
#include "set.h"
|
|
#include "rdd.api"
|
|
#include "ctoharb.h"
|
|
#include "set.ch"
|
|
|
|
#define HARBOUR_MAX_RDD_DRIVERNAME_LENGTH 32
|
|
|
|
typedef struct _RDDNODE
|
|
{
|
|
char szName[ HARBOUR_MAX_RDD_DRIVERNAME_LENGTH + 1 ];
|
|
USHORT uiType; /* Type of RDD */
|
|
RDDFUNCS pTable; /* Table of functions */
|
|
USHORT uiFunctions; /* Number of functions in the table */
|
|
USHORT uiAreaSize; /* Size of the WorkArea */
|
|
struct _RDDNODE * pNext; /* Next RDD in the list */
|
|
} RDDNODE, * PRDDNODE;
|
|
|
|
typedef struct _AREANODE
|
|
{
|
|
void * pArea; /* WorkAreas with different sizes */
|
|
struct _AREANODE * pPrev; /* Prev WorkArea in the list */
|
|
struct _AREANODE * pNext; /* Next WorkArea in the list */
|
|
} AREANODE, * PAREANODE;
|
|
|
|
void MyError( char * szError, char * szParam )
|
|
{
|
|
printf( "\n%s %s\n\7", szError, szParam );
|
|
}
|
|
|
|
HARBOUR HB_BOF( void );
|
|
HARBOUR HB_DBCLOSEALL( void );
|
|
HARBOUR HB_DBCLOSEAREA( void );
|
|
HARBOUR HB_DBCREATE( void );
|
|
HARBOUR HB_DBGOBOTTOM( void );
|
|
HARBOUR HB_DBGOTO( void );
|
|
HARBOUR HB_DBGOTOP( void );
|
|
HARBOUR HB_DBSELECTAREA( void );
|
|
HARBOUR HB_DBSETDRIVER( void );
|
|
HARBOUR HB_DBSKIP( void );
|
|
HARBOUR HB_DBUSEAREA( void );
|
|
HARBOUR HB_EOF( void );
|
|
HARBOUR HB_FOUND( void );
|
|
HARBOUR HB_RDDLIST( void );
|
|
HARBOUR HB_RDDREGISTER( void );
|
|
HARBOUR HB_RDDSETDEFAULT( void );
|
|
|
|
HB_INIT_SYMBOLS_BEGIN( dbCmd__InitSymbols )
|
|
{ "BOF", FS_PUBLIC, HB_BOF, 0 },
|
|
{ "DBCLOSEALL", FS_PUBLIC, HB_DBCLOSEALL, 0 },
|
|
{ "DBCLOSEAREA", FS_PUBLIC, HB_DBCLOSEAREA, 0 },
|
|
{ "DBCREATE", FS_PUBLIC, HB_DBCREATE, 0 },
|
|
{ "DBGOBOTTOM", FS_PUBLIC, HB_DBGOBOTTOM, 0 },
|
|
{ "DBGOTO", FS_PUBLIC, HB_DBGOTO, 0 },
|
|
{ "DBGOTOP", FS_PUBLIC, HB_DBGOTOP, 0 },
|
|
{ "DBSELECTAREA", FS_PUBLIC, HB_DBSELECTAREA, 0 },
|
|
{ "DBSETDRIVER", FS_PUBLIC, HB_DBSETDRIVER, 0 },
|
|
{ "DBSKIP", FS_PUBLIC, HB_DBSKIP, 0 },
|
|
{ "DBUSEAREA", FS_PUBLIC, HB_DBUSEAREA, 0 },
|
|
{ "EOF", FS_PUBLIC, HB_EOF, 0 },
|
|
{ "FOUND", FS_PUBLIC, HB_FOUND, 0 },
|
|
{ "RDDLIST", FS_PUBLIC, HB_RDDLIST, 0 },
|
|
{ "RDDREGISTER", FS_PUBLIC, HB_RDDREGISTER, 0 },
|
|
{ "RDDSETDEFAULT", FS_PUBLIC, HB_RDDSETDEFAULT, 0 }
|
|
HB_INIT_SYMBOLS_END( dbCmd__InitSymbols );
|
|
#if ! defined(__GNUC__)
|
|
#pragma startup dbCmd__InitSymbols
|
|
#endif
|
|
|
|
/* From strings.c */
|
|
char * hb_strUpper( char * szText, long lLen );
|
|
|
|
extern STACK stack;
|
|
|
|
static char * szDefDriver; /* Default RDD name */
|
|
static USHORT uiCurrArea; /* Selectd area */
|
|
static PRDDNODE pRDDList; /* Registered RDD's */
|
|
static USHORT uiNetError; /* Error on Networked environments */
|
|
|
|
static PAREANODE pWorkAreas; /* WorkAreas */
|
|
static PAREANODE pCurrArea; /* Pointer to a selectd and valid area */
|
|
|
|
static void hb_CloseAll( void );
|
|
|
|
void hb_rddInitialize( void )
|
|
{
|
|
szDefDriver = ( char * ) hb_xgrab( 1 );
|
|
szDefDriver[ 0 ] = '\0';
|
|
pRDDList = 0;
|
|
pWorkAreas = 0;
|
|
pCurrArea = 0;
|
|
uiCurrArea = 1;
|
|
uiNetError = 0;
|
|
}
|
|
|
|
void hb_rddRelease( void )
|
|
{
|
|
PRDDNODE pRDDNode;
|
|
|
|
hb_CloseAll();
|
|
hb_xfree( szDefDriver );
|
|
|
|
while( pRDDList )
|
|
{
|
|
pRDDNode = pRDDList;
|
|
pRDDList = pRDDList->pNext;
|
|
hb_xfree( pRDDNode );
|
|
}
|
|
}
|
|
|
|
static void hb_CloseAll( void )
|
|
{
|
|
DBENTRYP_V pFunction;
|
|
|
|
pCurrArea = pWorkAreas;
|
|
while( pWorkAreas )
|
|
{
|
|
pCurrArea = pWorkAreas;
|
|
pWorkAreas = pWorkAreas->pNext;
|
|
if( !( ( AREAP ) pCurrArea->pArea )->lprfsHost )
|
|
MyError( "No table error ", "9xxxx" );
|
|
else
|
|
{
|
|
pFunction = ( ( AREAP ) pCurrArea->pArea )->lprfsHost->close;
|
|
if( !pFunction || ( ( * pFunction )( ( AREAP ) pCurrArea->pArea ) != SUCCESS ) )
|
|
MyError( "Internal error ", "9xxxx" );
|
|
}
|
|
hb_xfree( pCurrArea->pArea );
|
|
hb_xfree( pCurrArea );
|
|
}
|
|
uiCurrArea = 1;
|
|
pCurrArea = 0;
|
|
pWorkAreas = 0;
|
|
}
|
|
|
|
static PRDDNODE hb_FindRDDNode( char * szDriver )
|
|
{
|
|
PRDDNODE pRDDNode;
|
|
|
|
pRDDNode = pRDDList;
|
|
while( pRDDNode )
|
|
{
|
|
if( strcmp( pRDDNode->szName, szDriver ) == 0 ) /* Matched RDD */
|
|
return pRDDNode;
|
|
pRDDNode = pRDDNode->pNext;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static BOOL hb_rddRegister( char * szDriver, USHORT uiType )
|
|
{
|
|
PRDDNODE pRDDNode, pRDDNewNode;
|
|
PDYNSYM pGetFuncTable;
|
|
char * szGetFuncTable;
|
|
|
|
if( hb_FindRDDNode( szDriver ) ) /* Duplicated RDD */
|
|
return FALSE;
|
|
|
|
szGetFuncTable = ( char * ) hb_xgrab( strlen( szDriver ) + 14 );
|
|
strcpy( szGetFuncTable, szDriver );
|
|
strcat( szGetFuncTable, "_GETFUNCTABLE" );
|
|
pGetFuncTable = hb_FindDynSym( szGetFuncTable );
|
|
hb_xfree( szGetFuncTable );
|
|
if( !pGetFuncTable )
|
|
return FALSE; /* Not valid RDD */
|
|
|
|
/* Create a new RDD node */
|
|
pRDDNewNode = ( PRDDNODE ) hb_xgrab( sizeof( RDDNODE ) );
|
|
memset( pRDDNewNode, 0, sizeof( RDDNODE ) );
|
|
|
|
/* Fill the new RDD node */
|
|
strncpy( pRDDNewNode->szName, szDriver, HARBOUR_MAX_RDD_DRIVERNAME_LENGTH );
|
|
pRDDNewNode->uiType = uiType;
|
|
|
|
PushSymbol( pGetFuncTable->pSymbol ); /* Call <szDriver>_GETFUNCTABLE() */
|
|
PushNil();
|
|
PushLong( ( long ) &pRDDNewNode->uiFunctions );
|
|
PushLong( ( long ) &pRDDNewNode->pTable );
|
|
Do( 2 );
|
|
if ( hb_parni( -1 ) != SUCCESS )
|
|
{
|
|
hb_xfree( pRDDNewNode ); /* Delete de new RDD node */
|
|
return FALSE;
|
|
}
|
|
|
|
if( !pRDDList )
|
|
pRDDList = pRDDNewNode; /* First RDD node */
|
|
else
|
|
{
|
|
pRDDNode = pRDDList;
|
|
while( pRDDNode->pNext )
|
|
pRDDNode = pRDDNode->pNext; /* Locate the last RDD node */
|
|
pRDDNode->pNext = pRDDNewNode; /* Add the new RDD node */
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static USHORT hb_FindAlias( char * szAlias )
|
|
{
|
|
return 1; /* Not implemented yet */
|
|
}
|
|
|
|
static void hb_SelectFirstAvailable( void )
|
|
{
|
|
PAREANODE pAreaNode;
|
|
|
|
uiCurrArea = 1;
|
|
pAreaNode = pWorkAreas;
|
|
while( pAreaNode )
|
|
{
|
|
if( ( ( AREAP ) pAreaNode->pArea )->uiArea > uiCurrArea )
|
|
break;
|
|
else if( ( ( AREAP ) pAreaNode->pArea )->uiArea == uiCurrArea )
|
|
uiCurrArea++;
|
|
pAreaNode = pAreaNode->pNext;
|
|
}
|
|
pCurrArea = 0; /* Selected WorkArea must be created */
|
|
}
|
|
|
|
ERRCODE hb_rddInherit( PRDDFUNCS pTable, PRDDFUNCS pSubTable, PRDDFUNCS pSuperTable, PBYTE szDrvName )
|
|
{
|
|
USHORT uiCount;
|
|
DBENTRYP_V * pFunction, * pSubFunction;
|
|
|
|
if( !pTable )
|
|
return FAILURE;
|
|
|
|
/* Copy the pSuperTable into pTable */
|
|
memcpy( pTable, pSuperTable, sizeof( RDDFUNCS ) );
|
|
|
|
/* Copy the non NULL entries from pSubTable into pTable */
|
|
pFunction = ( DBENTRYP_V * ) pTable;
|
|
pSubFunction = ( DBENTRYP_V * ) pSubTable;
|
|
for( uiCount = 0; uiCount < RDDFUNCSCOUNT; uiCount++ )
|
|
{
|
|
if( * pSubFunction )
|
|
* pFunction = * pSubFunction;
|
|
pFunction += 1;
|
|
pSubFunction += 1;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
HARBOUR HB_BOF( void )
|
|
{
|
|
BOOL bBof = TRUE;
|
|
DBENTRYP_BP pFunction;
|
|
|
|
if( pCurrArea && ( ( AREAP ) pCurrArea->pArea )->lprfsHost )
|
|
{
|
|
pFunction = ( ( AREAP ) pCurrArea->pArea )->lprfsHost->bof;
|
|
if( pFunction )
|
|
( * pFunction )( ( AREAP ) pCurrArea->pArea, &bBof );
|
|
}
|
|
hb_retl( bBof );
|
|
}
|
|
|
|
HARBOUR HB_DBCLOSEALL( void )
|
|
{
|
|
hb_CloseAll();
|
|
}
|
|
|
|
HARBOUR HB_DBCLOSEAREA( void )
|
|
{
|
|
DBENTRYP_V pFunction;
|
|
|
|
if( !pCurrArea )
|
|
return;
|
|
|
|
if( !( ( AREAP ) pCurrArea->pArea )->lprfsHost )
|
|
MyError( "No table error ", "9xxxx" );
|
|
else
|
|
{
|
|
pFunction = ( ( AREAP ) pCurrArea->pArea )->lprfsHost->close;
|
|
if( !pFunction || ( ( * pFunction )( ( AREAP ) pCurrArea->pArea ) != SUCCESS ) )
|
|
MyError( "Internal error ", "9xxxx" );
|
|
}
|
|
|
|
if( pCurrArea->pPrev )
|
|
pCurrArea->pPrev->pNext = pCurrArea->pNext;
|
|
if( pCurrArea->pNext )
|
|
pCurrArea->pNext->pPrev = pCurrArea->pPrev;
|
|
|
|
if( pWorkAreas == pCurrArea ) /* Empty list */
|
|
pWorkAreas = 0;
|
|
|
|
hb_xfree( pCurrArea->pArea );
|
|
hb_xfree( pCurrArea );
|
|
pCurrArea = 0;
|
|
}
|
|
|
|
HARBOUR HB_DBCREATE( void )
|
|
{
|
|
char * szFileName, * szDriver;
|
|
PHB_ITEM pStruct;
|
|
WORD wLen;
|
|
PRDDNODE pRDDNode;
|
|
DBENTRYP_SP pFunction1;
|
|
DBENTRYP_VP pFunction2;
|
|
AREAP pTempArea;
|
|
USHORT uiSize;
|
|
DBOPENINFO pInfo;
|
|
|
|
szFileName = hb_parc( 1 );
|
|
pStruct = hb_param( 2 , IT_ARRAY );
|
|
if( ( strlen( szFileName) == 0 ) || !pStruct )
|
|
{
|
|
MyError( "DBCMD/1014 Argument error", "DBCREATE" );
|
|
return;
|
|
}
|
|
|
|
szDriver = hb_parc( 3 );
|
|
if( ( wLen = strlen( szDriver ) ) > 0 )
|
|
szDriver = hb_strUpper( szDriver, strlen( szDriver ) );
|
|
else
|
|
szDriver = szDefDriver;
|
|
|
|
if( !( pRDDNode = hb_FindRDDNode( szDriver ) ) )
|
|
{
|
|
MyError( "DBCMD/1015 Argument error", "DBCREATE" );
|
|
return;
|
|
}
|
|
|
|
pFunction1 = pRDDNode->pTable.structSize;
|
|
pFunction2 = pRDDNode->pTable.create;
|
|
if( ! pFunction1 || ! pFunction2 )
|
|
{
|
|
MyError( "Internal error ", "9xxxx" );
|
|
return;
|
|
}
|
|
uiSize = sizeof( AREA ); /* Default Size Area */
|
|
pTempArea = ( AREAP ) hb_xgrab( uiSize );
|
|
|
|
/* Need more space? */
|
|
if( ( * pFunction1 )( pTempArea, &uiSize ) != SUCCESS )
|
|
{
|
|
hb_xfree( pTempArea );
|
|
MyError( "Internal error ", "9xxxx" );
|
|
return;
|
|
}
|
|
if( uiSize != sizeof( AREA ) ) /* Size of Area changed */
|
|
pTempArea = ( AREAP ) hb_xrealloc( pTempArea, uiSize );
|
|
|
|
pRDDNode->uiAreaSize = uiSize; /* Update the size of WorkArea */
|
|
|
|
pInfo.abName = ( PBYTE ) szFileName;
|
|
if( ( * pFunction2 )( pTempArea, &pInfo ) != SUCCESS )
|
|
MyError( "Internal error ", "9xxxx" );
|
|
hb_xfree( pTempArea );
|
|
}
|
|
|
|
HARBOUR HB_DBGOBOTTOM( void )
|
|
{
|
|
DBENTRYP_V pFunction;
|
|
|
|
if( !pCurrArea )
|
|
{
|
|
MyError( "Alias not in use ", "1xxxx" );
|
|
return;
|
|
}
|
|
|
|
if( !( ( AREAP ) pCurrArea->pArea )->lprfsHost )
|
|
MyError( "No table error ", "9xxxx" );
|
|
else
|
|
{
|
|
pFunction = ( ( AREAP ) pCurrArea->pArea )->lprfsHost->goBottom;
|
|
if( ! pFunction )
|
|
MyError( "Internal error ", "9xxxx" );
|
|
else
|
|
( * pFunction )( ( AREAP ) pCurrArea->pArea );
|
|
}
|
|
}
|
|
|
|
HARBOUR HB_DBGOTO( void )
|
|
{
|
|
DBENTRYP_L pFunction;
|
|
|
|
if( !pCurrArea )
|
|
{
|
|
MyError( "Alias not in use ", "1xxxx" );
|
|
return;
|
|
}
|
|
|
|
if( !( ( AREAP ) pCurrArea->pArea )->lprfsHost )
|
|
MyError( "No table error ", "9xxxx" );
|
|
else
|
|
{
|
|
pFunction = ( ( AREAP ) pCurrArea->pArea )->lprfsHost->go;
|
|
if( ! pFunction )
|
|
MyError( "Internal error ", "9xxxx" );
|
|
else if( ISNUM( 1 ) )
|
|
( * pFunction )( ( AREAP ) pCurrArea->pArea, hb_parnl( 1 ) );
|
|
else
|
|
MyError( "DBCMD/1068 Argument error", "DBGOTO" );
|
|
}
|
|
}
|
|
|
|
HARBOUR HB_DBGOTOP( void )
|
|
{
|
|
DBENTRYP_V pFunction;
|
|
|
|
if( !pCurrArea )
|
|
{
|
|
MyError( "Alias not in use ", "1xxxx" );
|
|
return;
|
|
}
|
|
|
|
if( !( ( AREAP ) pCurrArea->pArea )->lprfsHost )
|
|
MyError( "No table error ", "9xxxx" );
|
|
else
|
|
{
|
|
pFunction = ( ( AREAP ) pCurrArea->pArea )->lprfsHost->goTop;
|
|
if( ! pFunction )
|
|
MyError( "Internal error ", "9xxxx" );
|
|
else
|
|
( * pFunction )( ( AREAP ) pCurrArea->pArea );
|
|
}
|
|
}
|
|
|
|
HARBOUR HB_DBSELECTAREA( void )
|
|
{
|
|
USHORT uiNewArea;
|
|
char * szAlias;
|
|
PAREANODE pAreaNode;
|
|
|
|
if( ISCHAR( 1 ) )
|
|
{
|
|
szAlias = hb_parc( 1 );
|
|
if( ( uiNewArea = hb_FindAlias( szAlias ) ) == 0 )
|
|
{
|
|
MyError( "DBCMD/1002 Alias not found", szAlias );
|
|
return;
|
|
}
|
|
}
|
|
else if( !ISNUM( 1 ) )
|
|
{
|
|
MyError( "DBCMD/1068 Argument error", "DBSELECTAREA" );
|
|
return;
|
|
}
|
|
else
|
|
uiNewArea = hb_parni( 1 );
|
|
|
|
if( uiNewArea == 0 )
|
|
hb_SelectFirstAvailable();
|
|
else
|
|
uiCurrArea = uiNewArea;
|
|
|
|
pAreaNode = pWorkAreas;
|
|
while( pAreaNode )
|
|
{
|
|
if( ( ( AREAP ) pAreaNode->pArea )->uiArea == uiCurrArea )
|
|
{
|
|
pCurrArea = pAreaNode; /* Select a valid WorkArea */
|
|
return;
|
|
}
|
|
pAreaNode = pAreaNode->pNext;
|
|
}
|
|
pCurrArea = 0; /* Selected WorkArea is closed */
|
|
}
|
|
|
|
HARBOUR HB_DBSETDRIVER( void )
|
|
{
|
|
HB_RDDSETDEFAULT();
|
|
}
|
|
|
|
HARBOUR HB_DBSKIP( void )
|
|
{
|
|
DBENTRYP_L pFunction;
|
|
PHB_ITEM pItem;
|
|
LONG lToSkip = 1;
|
|
|
|
if( !pCurrArea )
|
|
{
|
|
MyError( "Alias not in use ", "1xxxx" );
|
|
return;
|
|
}
|
|
|
|
if( !( ( AREAP ) pCurrArea->pArea )->lprfsHost )
|
|
MyError( "No table error ", "9xxxx" );
|
|
else
|
|
{
|
|
pFunction = ( ( AREAP ) pCurrArea->pArea )->lprfsHost->skip;
|
|
if( ! pFunction )
|
|
MyError( "Internal error ", "9xxxx" );
|
|
else
|
|
{
|
|
pItem = hb_param( 1, IT_NUMERIC );
|
|
if( pItem )
|
|
{
|
|
if( pItem->type == IT_INTEGER )
|
|
lToSkip = pItem->item.asInteger.value;
|
|
else if( pItem->type == IT_LONG )
|
|
lToSkip = pItem->item.asLong.value;
|
|
}
|
|
( * pFunction )( ( AREAP ) pCurrArea->pArea, lToSkip );
|
|
}
|
|
}
|
|
}
|
|
|
|
HARBOUR HB_DBUSEAREA( void )
|
|
{
|
|
char * szDriver, * szFileName, * szAlias;
|
|
WORD wLen;
|
|
PRDDNODE pRDDNode;
|
|
PAREANODE pAreaNode;
|
|
USHORT uiSize;
|
|
DBENTRYP_V pFunction1;
|
|
DBENTRYP_SP pFunction2;
|
|
DBENTRYP_VP pFunction3;
|
|
DBOPENINFO pInfo;
|
|
|
|
uiNetError = 0;
|
|
|
|
if( hb_parl( 1 ) )
|
|
hb_SelectFirstAvailable();
|
|
else if( pCurrArea ) /* If current WorkArea is in use then close it */
|
|
{
|
|
pFunction1 = ( ( AREAP ) pCurrArea->pArea )->lprfsHost->close;
|
|
if( !pFunction1 || ( ( * pFunction1 )( ( AREAP ) pCurrArea->pArea ) != SUCCESS ) )
|
|
{
|
|
MyError( "Internal error ", "9xxxx" );
|
|
return;
|
|
}
|
|
if( pCurrArea->pPrev )
|
|
pCurrArea->pPrev->pNext = pCurrArea->pNext;
|
|
if( pCurrArea->pNext )
|
|
pCurrArea->pPrev = pCurrArea->pPrev;
|
|
hb_xfree( pCurrArea->pArea );
|
|
hb_xfree( pCurrArea );
|
|
pCurrArea = 0;
|
|
}
|
|
|
|
szDriver = hb_parc( 2 );
|
|
if( ( wLen = strlen( szDriver ) ) > 0 )
|
|
szDriver = hb_strUpper( szDriver, strlen( szDriver ) );
|
|
else
|
|
szDriver = szDefDriver;
|
|
|
|
if( !( pRDDNode = hb_FindRDDNode( szDriver ) ) )
|
|
{
|
|
MyError( "DBCMD/1015 Argument error", "DBCREATE" );
|
|
return;
|
|
}
|
|
|
|
szFileName = hb_parc( 3 );
|
|
if( strlen( szFileName ) == 0 )
|
|
{
|
|
MyError( "DBCMD/1005 Argument error", "DBUSEAREA" );
|
|
return;
|
|
}
|
|
|
|
/* TODO: Implement szAlias from szFilename */
|
|
szAlias = hb_parc( 4 );
|
|
if( strlen( szAlias ) == 0 )
|
|
szAlias = szFileName;
|
|
|
|
/* Create a new WorkArea node */
|
|
|
|
pCurrArea = ( PAREANODE ) hb_xgrab( sizeof( AREANODE ) );
|
|
|
|
if( pRDDNode->uiAreaSize == 0 ) /* Calculate the size of WorkArea */
|
|
{
|
|
uiSize = sizeof( AREA ); /* Default Size Area */
|
|
pCurrArea->pArea = hb_xgrab( uiSize );
|
|
pFunction2 = pRDDNode->pTable.structSize;
|
|
|
|
/* Need more space? */
|
|
if( !pFunction2 || ( * pFunction2 )( ( AREAP ) pCurrArea->pArea, &uiSize ) != SUCCESS )
|
|
{
|
|
hb_xfree( pCurrArea->pArea );
|
|
hb_xfree( pCurrArea );
|
|
pCurrArea = 0;
|
|
MyError( "Internal error ", "9xxxx" );
|
|
return;
|
|
}
|
|
|
|
if( uiSize != sizeof( AREA ) ) /* Size of Area changed */
|
|
pCurrArea->pArea = hb_xrealloc( pCurrArea->pArea, uiSize );
|
|
|
|
pRDDNode->uiAreaSize = uiSize; /* Update the size of WorkArea */
|
|
}
|
|
else
|
|
pCurrArea->pArea = hb_xgrab( pRDDNode->uiAreaSize );
|
|
|
|
( ( AREAP ) pCurrArea->pArea )->lprfsHost = &pRDDNode->pTable;
|
|
|
|
if( !( ( AREAP ) pCurrArea->pArea )->lprfsHost )
|
|
{
|
|
hb_xfree( pCurrArea->pArea );
|
|
hb_xfree( pCurrArea );
|
|
pCurrArea = 0;
|
|
MyError( "No table error ", "9xxxx" );
|
|
return;
|
|
}
|
|
|
|
pInfo.uiArea = uiCurrArea;
|
|
pInfo.abName = ( PBYTE ) szFileName;
|
|
pInfo.atomAlias = ( PBYTE ) szAlias;
|
|
pInfo.fShared = ISLOG( 5 ) ? hb_parl( 5 ) : !hb_set.HB_SET_EXCLUSIVE;
|
|
pInfo.fReadonly = ISLOG( 6 ) ? hb_parl( 6 ) : FALSE;
|
|
|
|
pFunction3 = pRDDNode->pTable.open;
|
|
if( !pFunction3 || ( * pFunction3 )( ( AREAP ) pCurrArea->pArea, &pInfo ) != SUCCESS )
|
|
{
|
|
hb_xfree( pCurrArea->pArea );
|
|
hb_xfree( pCurrArea );
|
|
pCurrArea = 0;
|
|
MyError( "No table error ", "9xxxx" );
|
|
return;
|
|
}
|
|
|
|
/* Insert the new WorkArea node */
|
|
|
|
if( !pWorkAreas )
|
|
{
|
|
pWorkAreas = pCurrArea; /* The new WorkArea node is the first */
|
|
return;
|
|
}
|
|
|
|
pAreaNode = pWorkAreas;
|
|
while( pAreaNode->pNext )
|
|
{
|
|
if( ( ( AREAP ) pAreaNode->pArea )->uiArea > uiCurrArea )
|
|
{
|
|
/* Insert the new WorkArea node */
|
|
pCurrArea->pPrev = pAreaNode->pPrev;
|
|
pCurrArea->pNext = pAreaNode;
|
|
pAreaNode->pPrev = pCurrArea;
|
|
if( pCurrArea->pPrev )
|
|
pCurrArea->pPrev->pNext = pCurrArea;
|
|
}
|
|
pAreaNode = pAreaNode->pNext;
|
|
}
|
|
pAreaNode->pNext = pCurrArea; /* Append the new WorkArea node */
|
|
pCurrArea->pPrev = pAreaNode;
|
|
}
|
|
|
|
HARBOUR HB_EOF( void )
|
|
{
|
|
BOOL bEof = TRUE;
|
|
DBENTRYP_BP pFunction;
|
|
|
|
if( pCurrArea )
|
|
{
|
|
if( !( ( AREAP ) pCurrArea->pArea )->lprfsHost )
|
|
MyError( "No table error ", "9xxxx" );
|
|
else
|
|
{
|
|
pFunction = ( ( AREAP ) pCurrArea->pArea )->lprfsHost->eof;
|
|
if( pFunction )
|
|
( * pFunction )( ( AREAP ) pCurrArea->pArea, &bEof );
|
|
}
|
|
}
|
|
hb_retl( bEof );
|
|
}
|
|
|
|
HARBOUR HB_FOUND( void )
|
|
{
|
|
BOOL bFound = FALSE;
|
|
DBENTRYP_BP pFunction;
|
|
|
|
if( pCurrArea )
|
|
{
|
|
if( !( ( AREAP ) pCurrArea->pArea )->lprfsHost )
|
|
MyError( "No table error ", "9xxxx" );
|
|
else
|
|
{
|
|
pFunction = ( ( AREAP ) pCurrArea->pArea )->lprfsHost->found;
|
|
if( pFunction )
|
|
( * pFunction )( ( AREAP ) pCurrArea->pArea, &bFound );
|
|
}
|
|
}
|
|
hb_retl( bFound );
|
|
}
|
|
|
|
HARBOUR HB_RDDLIST( void )
|
|
{
|
|
USHORT uiType;
|
|
PHB_ITEM pSubArray, pName, pType;
|
|
PRDDNODE pRDDNode;
|
|
|
|
uiType = hb_parni( 1 ); /* 0 all types of RDD's */
|
|
hb_arrayNew( &stack.Return, 0 );
|
|
pSubArray = hb_itemArrayNew( 2 );
|
|
pName = hb_itemNew( 0 );
|
|
pType = hb_itemNew( 0 );
|
|
pRDDNode = pRDDList;
|
|
while( pRDDNode )
|
|
{
|
|
if( ( uiType == 0 ) || ( pRDDNode->uiType == uiType ) )
|
|
{
|
|
hb_arraySet( pSubArray, 1, hb_itemPutC( pName, pRDDNode->szName ) );
|
|
hb_arraySet( pSubArray, 2, hb_itemPutNL( pType, pRDDNode->uiType ) );
|
|
hb_arrayAdd( &stack.Return, pSubArray );
|
|
}
|
|
pRDDNode = pRDDNode->pNext;
|
|
}
|
|
hb_itemRelease( pName );
|
|
hb_itemRelease( pType );
|
|
hb_itemRelease( pSubArray );
|
|
}
|
|
|
|
HARBOUR HB_RDDREGISTER( void )
|
|
{
|
|
char * szDriver;
|
|
WORD wLen;
|
|
|
|
szDriver = hb_parc( 1 );
|
|
if( ( wLen = strlen( szDriver ) ) > 0 )
|
|
{
|
|
szDriver = hb_strUpper( szDriver, wLen );
|
|
if( hb_rddRegister( szDriver, hb_parni( 2 ) ) )
|
|
return;
|
|
}
|
|
MyError( "Internal error", "RDDREGISTER" );
|
|
}
|
|
|
|
HARBOUR HB_RDDSETDEFAULT( void )
|
|
{
|
|
char * szNewDriver;
|
|
WORD wLen;
|
|
|
|
hb_retc( szDefDriver );
|
|
szNewDriver = hb_parc( 1 );
|
|
if( ( wLen = strlen( szNewDriver ) ) > 0 )
|
|
{
|
|
szNewDriver = hb_strUpper( szNewDriver, wLen );
|
|
szDefDriver = ( char * ) hb_xrealloc( szDefDriver, wLen + 1 );
|
|
strcpy( szDefDriver, szNewDriver );
|
|
}
|
|
else
|
|
MyError( "Argument error", "RDDSETDEFAULT" );
|
|
}
|