fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ab5eedbb2fcd901e6ea928367deecda0b7cb63ba
harbour-core/harbour/source/vm/memvars.c
Viktor Szakats d8654833af 2008-06-15 23:10 UTC+0200 Viktor Szakats (harbour.01 syenar hu) 
* source/vm/memvars.c
     * Minor format.

   * contrib/hbmzip/hbmzip.c
     * Minor cleanups.

   * contrib/hbtip/tests/httpadv.prg
   * contrib/hbtip/tests/dnldftp.prg
   * contrib/hbtip/tests/upld_ftp.prg
   * contrib/hbtip/tests/tipmail.prg
   * contrib/hbtip/tests/loadhtml.prg
   * contrib/hbtip/tests/ftpadv.prg
     * Changed to compile in Harbour.
2008-06-15 21:11:36 +00:00

1663 lines
47 KiB
C
Raw Blame History

/*
* $Id$
*/
/*
* Harbour Project source code:
* Memvar (PRIVATE/PUBLIC) runtime support
*
* Copyright 1999 Ryszard Glab <rglab@imid.med.pl>
* www - http://www.harbour-project.org
*
* 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, 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 software; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/).
*
* As a special exception, the Harbour Project gives permission for
* additional uses of the text contained in its release of Harbour.
*
* The exception is that, if you link the Harbour libraries with other
* files to produce an executable, this does not by itself cause the
* resulting executable to be covered by the GNU General Public License.
* Your use of that executable is in no way restricted on account of
* linking the Harbour library code into it.
*
* This exception does not however invalidate any other reasons why
* the executable file might be covered by the GNU General Public License.
*
* This exception applies only to the code released by the Harbour
* Project under the name Harbour. If you copy code from other
* Harbour Project or Free Software Foundation releases into a copy of
* Harbour, as the General Public License permits, the exception does
* not apply to the code that you add in this way. To avoid misleading
* anyone as to the status of such modified files, you must delete
* this exception notice from them.
*
* If you write modifications of your own for Harbour, it is your choice
* whether to permit this exception to apply to your modifications.
* If you do not wish that, delete this exception notice.
*
*/
/*
* The following parts are Copyright of the individual authors.
* www - http://www.harbour-project.org
*
* Copyright 1999-2001 Viktor Szakats <viktor.szakats@syenar.hu>
* __MVSAVE()
* __MVRESTORE() (Thanks to Dave Pearson and Jo French for the original
* Clipper function (FReadMem()) to read .mem files)
*
* See doc/license.txt for licensing terms.
*
*/
#include <ctype.h> /* for toupper() function */
#include "hbvmopt.h"
#include "hbapi.h"
#include "hbapiitm.h"
#include "hbapierr.h"
#include "hbapifs.h" /* for __MVSAVE()/__MVRESTORE() */
#include "hbdate.h" /* for __MVSAVE()/__MVRESTORE() */
#include "hbcomp.h" /* for VS_* macros */
#include "error.ch"
#include "hbmemvar.ch"
#include "hbset.h"
#include "hbstack.h"
static PHB_DYNS * s_privateStack = NULL;
static ULONG s_privateStackSize = 0;
static ULONG s_privateStackCnt = 0;
static ULONG s_privateStackBase = 0;
static ULONG s_globalTableSize = 0;
static ULONG s_globalFirstFree = 0;
static ULONG s_globalLastFree = 0;
static HB_VALUE_PTR s_globalTable = NULL;
#define TABLE_INITHB_VALUE 100
#define TABLE_EXPANDHB_VALUE 50
struct mv_PUBLIC_var_info
{
int iPos;
BOOL bFound;
HB_DYNS_PTR pDynSym;
};
static void hb_memvarCreateFromDynSymbol( PHB_DYNS, BYTE, PHB_ITEM );
void hb_memvarsInit( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarsInit()"));
s_globalTable = ( HB_VALUE_PTR ) hb_xgrab( sizeof( HB_VALUE ) * TABLE_INITHB_VALUE );
s_globalTableSize = TABLE_INITHB_VALUE;
s_globalFirstFree = 0;
s_globalLastFree = 1;
s_privateStack = ( PHB_DYNS * ) hb_xgrab( sizeof( PHB_DYNS ) * TABLE_INITHB_VALUE );
s_privateStackSize = TABLE_INITHB_VALUE;
s_privateStackCnt = s_privateStackBase = 0;
}
void hb_memvarsFree( void )
{
if( s_globalTable )
hb_xfree( s_globalTable );
if( s_privateStack )
hb_xfree( s_privateStack );
}
/*
* This function base address of values table
*/
HB_VALUE_PTR *hb_memvarValueBaseAddress( void )
{
return &s_globalTable;
}
/*
* This function creates new global value.
*
* pSource = item value that have to be stored or NULL
* hPrevMemvar
* -1 if function is called to create memvar variable for a codeblock
* (to store detached local variable) - in this case we have to do
* exact copy of passed item (without duplicating its value and
* without reference decrementing)
* else we are creating regular memvar variable (PUBLIC or PRIVATE)
* In this case we have to do normal item coping.
* hPrevMemvar > 0 is old memvar value which will be hidden by
* new PRIVATE variable
*
* Returns:
* handle to variable memory or fails
*
*/
static HB_HANDLE hb_memvarValueNew( HB_ITEM_PTR pSource, HB_HANDLE hPrevMemvar )
{
HB_VALUE_PTR pValue;
HB_HANDLE hValue; /* handle 0 is reserved */
/* = 1 removed, since it's initialized in all branches. Caused a warning with Borland C++ */
HB_TRACE(HB_TR_DEBUG, ("hb_memvarValueNew(%p, %lu)", pSource, hPrevMemvar));
if( s_globalFirstFree )
{
/* There are holes in the table - get a first available one
*/
hValue = s_globalFirstFree;
s_globalFirstFree = s_globalTable[ hValue ].hPrevMemvar;
}
else
{
/* Allocate the value from the end of table
*/
if( s_globalLastFree < s_globalTableSize )
{
hValue = s_globalLastFree++;
}
else
{
/* No more free values in the table - expand the table
*/
hValue = s_globalTableSize;
s_globalLastFree = s_globalTableSize + 1;
s_globalTableSize += TABLE_EXPANDHB_VALUE;
s_globalTable = ( HB_VALUE_PTR ) hb_xrealloc( s_globalTable, sizeof( HB_VALUE ) * s_globalTableSize );
}
}
pValue = s_globalTable + hValue;
pValue->pVarItem = ( HB_ITEM_PTR ) hb_xgrab( sizeof( HB_ITEM ) );
pValue->pVarItem->type = HB_IT_NIL;
pValue->hPrevMemvar = hPrevMemvar;
pValue->counter = 1;
if( pSource )
{
if( hPrevMemvar == ( HB_HANDLE ) -1 ) /* detached local - copy its body only */
{
memcpy( pValue->pVarItem, pSource, sizeof( HB_ITEM ) );
pValue->pVarItem->type &= ~HB_IT_DEFAULT;
}
else
{
hb_itemCopy( pValue->pVarItem, pSource );
/* Remove MEMOFLAG if exists (assignment from field). */
pValue->pVarItem->type &= ~HB_IT_MEMOFLAG;
}
}
HB_TRACE(HB_TR_INFO, ("hb_memvarValueNew: memvar item created with handle %i", hValue));
return hValue;
}
static void hb_memvarRecycle( HB_HANDLE hValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarRecycle(%lu)", hValue));
s_globalTable[ hValue ].hPrevMemvar = s_globalFirstFree;
s_globalFirstFree = hValue;
}
/*
* This function increases the number of references to passed global value
*/
void hb_memvarValueIncRef( HB_HANDLE hValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarValueIncRef(%lu)", hValue));
s_globalTable[ hValue ].counter++;
HB_TRACE(HB_TR_INFO, ("Memvar item (%i) increment refCounter=%li", hValue, s_globalTable[ hValue ].counter));
}
/*
* This function decreases the number of references to passed global value.
* If it is the last reference then this value is deleted.
*/
void hb_memvarValueDecRef( HB_HANDLE hValue )
{
HB_VALUE_PTR pValue;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarValueDecRef(%lu)", hValue));
pValue = s_globalTable + hValue;
HB_TRACE(HB_TR_INFO, ("Memvar item (%i) decrement refCounter=%li", hValue, pValue->counter-1));
if( --pValue->counter == 0 )
{
if( HB_IS_COMPLEX( pValue->pVarItem ) )
hb_itemClear( pValue->pVarItem );
hb_xfree( pValue->pVarItem );
hb_memvarRecycle( hValue );
HB_TRACE(HB_TR_INFO, ("Memvar item (%i) deleted", hValue));
}
}
/*
* Detach local variable (swap current value with a memvar handle)
*/
static void hb_memvarDetachDynSym( PHB_DYNS pDynSym, BOOL fRestore )
{
HB_VALUE_PTR pValue;
HB_HANDLE hValue;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarDetachDynSym(%p, %d)", pDynSym, fRestore));
hValue = pDynSym->hMemvar;
pValue = s_globalTable + hValue;
pDynSym->hMemvar = fRestore ? pValue->hPrevMemvar : 0;
if( --pValue->counter == 0 )
{
if( HB_IS_COMPLEX( pValue->pVarItem ) )
hb_itemClear( pValue->pVarItem );
hb_xfree( pValue->pVarItem );
hb_memvarRecycle( hValue );
HB_TRACE(HB_TR_INFO, ("Memvar item (%i) deleted", hValue));
}
else
{
/* memvar is still accessible by active references on HVM stack
* and/or as detached local in codeblocks - so we have to mark it
* as detached or it will be scanned in GC mark pass and if some
* cross references exists it will never be freed.
*/
pValue->hPrevMemvar = ( HB_HANDLE ) -1;
}
}
/*
* Detach local variable (swap current value with a memvar handle)
*/
HB_ITEM_PTR hb_memvarDetachLocal( HB_ITEM_PTR pLocal )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarDetachLocal(%p)", pLocal));
if( HB_IS_BYREF( pLocal ) )
{
do
{
if( HB_IS_MEMVAR( pLocal ) )
break;
else if( HB_IS_ENUM( pLocal ) && !pLocal->item.asEnum.valuePtr )
{
PHB_ITEM pBase = HB_IS_BYREF( pLocal->item.asEnum.basePtr ) ?
hb_itemUnRef( pLocal->item.asEnum.basePtr ) :
pLocal->item.asEnum.basePtr;
if( HB_IS_ARRAY( pBase ) )
{
PHB_ITEM pItem = hb_itemNew( NULL );
hb_arrayGetItemRef( pBase, pLocal->item.asEnum.offset, pItem );
pLocal->item.asEnum.valuePtr = pItem;
pLocal = pItem;
break;
}
}
else if( pLocal->item.asRefer.value >= 0 &&
pLocal->item.asRefer.offset == 0 )
break;
pLocal = hb_itemUnRefOnce( pLocal );
}
while( HB_IS_BYREF( pLocal ) );
}
/* Change the value only if this variable is not referenced
* by another codeblock yet.
* In this case we have to copy the current value to a global memory
* pool so it can be shared by codeblocks
*/
if( ! HB_IS_MEMVAR( pLocal ) )
{
HB_HANDLE hMemvar = hb_memvarValueNew( pLocal, ( HB_HANDLE ) -1 );
pLocal->type = HB_IT_BYREF | HB_IT_MEMVAR;
pLocal->item.asMemvar.itemsbase = &s_globalTable;
pLocal->item.asMemvar.value = hMemvar;
}
return pLocal;
}
/*
* This function pushes passed dynamic symbol that belongs to PRIVATE variable
* into the stack. The value will be popped from it if the variable falls
* outside the scope (either by using RELEASE, CLEAR ALL, CLEAR MEMORY or by
* an exit from the function/procedure)
*
*/
static void hb_memvarAddPrivate( PHB_DYNS pDynSym )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarAddPrivate(%p)", pDynSym));
/* Allocate the value from the end of table
*/
if( s_privateStackCnt == s_privateStackSize )
{
/* No more free values in the table - expand the table
*/
s_privateStackSize += TABLE_EXPANDHB_VALUE;
s_privateStack = ( PHB_DYNS * ) hb_xrealloc( s_privateStack, sizeof( PHB_DYNS ) * s_privateStackSize );
}
s_privateStack[ s_privateStackCnt++ ] = pDynSym;
}
/*
* This function returns current PRIVATE variables stack base
*/
ULONG hb_memvarGetPrivatesBase( void )
{
ULONG ulBase = s_privateStackBase;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetPrivatesBase()"));
s_privateStackBase = s_privateStackCnt;
return ulBase;
}
/*
* This function releases PRIVATE variables created after passed base
*/
void hb_memvarSetPrivatesBase( ULONG ulBase )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarSetPrivatesBase(%lu)", ulBase));
while( s_privateStackCnt > s_privateStackBase )
{
if( s_privateStack[ --s_privateStackCnt ]->hMemvar )
{
/* Restore previous value for variables that were overridden
*/
hb_memvarDetachDynSym( s_privateStack[ s_privateStackCnt ], TRUE );
}
}
s_privateStackBase = ulBase;
}
/*
* Update PRIVATE base ofsset so they will not be removed
* when function return
*/
void hb_memvarUpdatePrivatesBase( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarUpdatePrivatesBase()"));
s_privateStackBase = s_privateStackCnt;
}
/*
* This functions copies passed item value into the memvar pointed
* by symbol
*
* pMemvar - symbol associated with a variable
* pItem - value to store in memvar
*
*/
void hb_memvarSetValue( PHB_SYMB pMemvarSymb, HB_ITEM_PTR pItem )
{
PHB_DYNS pDyn;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarSetValue(%p, %p)", pMemvarSymb, pItem));
pDyn = ( PHB_DYNS ) pMemvarSymb->pDynSym;
if( pDyn )
{
HB_TRACE(HB_TR_INFO, ("Memvar item (%i)(%s) assigned", pDyn->hMemvar, pMemvarSymb->szName));
if( pDyn->hMemvar )
{
/* value is already created */
hb_itemCopyToRef( s_globalTable[ pDyn->hMemvar ].pVarItem, pItem );
/* Remove MEMOFLAG if exists (assignment from field). */
s_globalTable[ pDyn->hMemvar ].pVarItem->type &= ~HB_IT_MEMOFLAG;
}
else
{
/* assignment to undeclared memvar - PRIVATE is assumed */
hb_memvarCreateFromDynSymbol( pDyn, VS_PRIVATE, pItem );
}
}
else
hb_errInternal( HB_EI_MVBADSYMBOL, NULL, pMemvarSymb->szName, NULL );
}
ERRCODE hb_memvarGet( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb )
{
PHB_DYNS pDyn;
ERRCODE bSuccess = FAILURE;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarGet(%p, %p)", pItem, pMemvarSymb));
pDyn = ( PHB_DYNS ) pMemvarSymb->pDynSym;
if( pDyn )
{
HB_TRACE(HB_TR_INFO, ("Memvar item (%i)(%s) queried", pDyn->hMemvar, pMemvarSymb->szName));
if( pDyn->hMemvar )
{
/* value is already created
*/
HB_ITEM_PTR pGetItem = s_globalTable[ pDyn->hMemvar ].pVarItem;
if( HB_IS_BYREF( pGetItem ) )
hb_itemCopy( pItem, hb_itemUnRef( pGetItem ) );
else
hb_itemCopy( pItem, pGetItem );
bSuccess = SUCCESS;
}
}
else
hb_errInternal( HB_EI_MVBADSYMBOL, NULL, pMemvarSymb->szName, NULL );
return bSuccess;
}
void hb_memvarGetValue( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetValue(%p, %p)", pItem, pMemvarSymb));
if( hb_memvarGet( pItem, pMemvarSymb ) == FAILURE )
{
/* Generate an error with retry possibility
* (user created error handler can create this variable)
*/
HB_ITEM_PTR pError;
pError = hb_errRT_New( ES_ERROR, NULL, EG_NOVAR, 1003,
NULL, pMemvarSymb->szName, 0, EF_CANRETRY );
while( hb_errLaunch( pError ) == E_RETRY )
{
if( hb_memvarGet( pItem, pMemvarSymb ) == SUCCESS )
break;
}
hb_errRelease( pError );
}
}
void hb_memvarGetRefer( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb )
{
PHB_DYNS pDyn;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetRefer(%p, %p)", pItem, pMemvarSymb));
pDyn = ( PHB_DYNS ) pMemvarSymb->pDynSym;
if( pDyn )
{
HB_TRACE(HB_TR_INFO, ("Memvar item (%i)(%s) referenced", pDyn->hMemvar, pMemvarSymb->szName));
if( pDyn->hMemvar )
{
PHB_ITEM pMemvar = s_globalTable[ pDyn->hMemvar ].pVarItem;
if( HB_IS_BYREF( pMemvar ) )
hb_itemCopy( pItem, pMemvar );
else
{
/* value is already created */
pItem->type = HB_IT_BYREF | HB_IT_MEMVAR;
pItem->item.asMemvar.value = pDyn->hMemvar;
pItem->item.asMemvar.itemsbase = &s_globalTable;
++s_globalTable[ pDyn->hMemvar ].counter;
}
}
else
{
/* Generate an error with retry possibility
* (user created error handler can make this variable accessible)
*/
HB_ITEM_PTR pError;
pError = hb_errRT_New( ES_ERROR, NULL, EG_NOVAR, 1003,
NULL, pMemvarSymb->szName, 0, EF_CANRETRY );
while( hb_errLaunch( pError ) == E_RETRY )
{
if( pDyn->hMemvar )
{
PHB_ITEM pMemvar = s_globalTable[ pDyn->hMemvar ].pVarItem;
if( HB_IS_BYREF( pMemvar ) )
hb_itemCopy( pItem, pMemvar );
else
{
/* value is already created */
pItem->type = HB_IT_BYREF | HB_IT_MEMVAR;
pItem->item.asMemvar.value = pDyn->hMemvar;
pItem->item.asMemvar.itemsbase = &s_globalTable;
++s_globalTable[ pDyn->hMemvar ].counter;
}
break;
}
}
hb_errRelease( pError );
}
}
else
hb_errInternal( HB_EI_MVBADSYMBOL, NULL, pMemvarSymb->szName, NULL );
}
PHB_ITEM hb_memvarGetItem( PHB_SYMB pMemvarSymb )
{
PHB_DYNS pDyn;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetItem(%p)", pMemvarSymb));
pDyn = ( PHB_DYNS ) pMemvarSymb->pDynSym;
if( pDyn && pDyn->hMemvar )
{
HB_ITEM_PTR pItem = s_globalTable[ pDyn->hMemvar ].pVarItem;
if( HB_IS_BYREF( pItem ) )
return hb_itemUnRef( pItem );
else
return pItem;
}
return NULL;
}
/*
*/
void hb_memvarNewParameter( PHB_SYMB pSymbol, PHB_ITEM pValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarNewParameter(%p, %p)", pSymbol, pValue));
hb_memvarCreateFromDynSymbol( pSymbol->pDynSym, VS_PRIVATE, pValue );
}
static HB_DYNS_PTR hb_memvarFindSymbol( char * szArg, ULONG ulLen )
{
HB_DYNS_PTR pDynSym = NULL;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarFindSymbol(%p,%lu)", szArg, ulLen));
if( ulLen && szArg && *szArg )
{
char szUprName[ HB_SYMBOL_NAME_LEN + 1 ];
int iSize = 0;
do
{
char cChar = *szArg++;
if( cChar >= 'a' && cChar <= 'z' )
{
szUprName[ iSize++ ] = cChar - ( 'a' - 'A' );
}
else if( cChar == ' ' || cChar == '\t' || cChar == '\n' )
{
if( iSize )
break;
}
else if( !cChar )
{
break;
}
else
{
szUprName[ iSize++ ] = cChar;
}
}
while( --ulLen && iSize < HB_SYMBOL_NAME_LEN );
if( iSize )
{
szUprName[ iSize ] = '\0';
pDynSym = hb_dynsymFind( szUprName );
}
}
return pDynSym;
}
char * hb_memvarGetStrValuePtr( char * szVarName, ULONG *pulLen )
{
HB_DYNS_PTR pDynVar;
char * szValue = NULL;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetStrValuePtr(%s, %li)", szVarName, pulLen));
pDynVar = hb_memvarFindSymbol( szVarName, *pulLen );
if( pDynVar )
{
/* there is dynamic symbol with the requested name - check if it is
* a memvar variable
*/
if( pDynVar->hMemvar )
{
/* variable contains some data
*/
HB_ITEM_PTR pItem = s_globalTable[ pDynVar->hMemvar ].pVarItem;
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem ); /* it is a PARAMETER variable */
if( HB_IS_STRING( pItem ) )
{
szValue = pItem->item.asString.value;
*pulLen = pItem->item.asString.length;
}
}
}
return szValue;
}
/*
* This function creates a value for memvar variable
*
* pMemvar - an item that stores the name of variable - it can be either
* the HB_IT_SYMBOL (if created by PUBLIC statement) or HB_IT_STRING
* (if created by direct call to __MVPUBLIC function)
* bScope - the scope of created variable - if a variable with the same name
* exists already then it's value is hidden by new variable with
* passed scope
* pValue - optional item used to initialize the value of created variable
* or NULL
*
*/
void hb_memvarCreateFromItem( PHB_ITEM pMemvar, BYTE bScope, PHB_ITEM pValue )
{
PHB_DYNS pDynVar = NULL;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarCreateFromItem(%p, %d, %p)", pMemvar, bScope, pValue));
/* find dynamic symbol or creeate one */
if( HB_IS_SYMBOL( pMemvar ) )
/* pDynVar = hb_dynsymGet( pMemvar->item.asSymbol.value->szName ); */
pDynVar = pMemvar->item.asSymbol.value->pDynSym;
else if( HB_IS_STRING( pMemvar ) )
pDynVar = hb_dynsymGet( pMemvar->item.asString.value );
if( pDynVar )
hb_memvarCreateFromDynSymbol( pDynVar, bScope, pValue );
else
hb_errRT_BASE( EG_ARG, 3008, NULL, "&", HB_ERR_ARGS_BASEPARAMS );
}
static void hb_memvarCreateFromDynSymbol( PHB_DYNS pDynVar, BYTE bScope, PHB_ITEM pValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarCreateFromDynSymbol(%p, %d, %p)", pDynVar, bScope, pValue));
if( bScope & VS_PUBLIC )
{
/* If the variable with the same name exists already
* then the current value have to be unchanged
*/
if( ! pDynVar->hMemvar )
{
pDynVar->hMemvar = hb_memvarValueNew( pValue, 0 );
if( !pValue )
{
/* new PUBLIC variable - initialize it to .F.
*/
s_globalTable[ pDynVar->hMemvar ].pVarItem->type = HB_IT_LOGICAL;
/* NOTE: PUBLIC variables named CLIPPER and HARBOUR are initialized */
/* to .T., this is normal Clipper behaviour. [vszakats] */
if( strcmp( pDynVar->pSymbol->szName, "HARBOUR" ) == 0 ||
strcmp( pDynVar->pSymbol->szName, "CLIPPER" ) == 0 )
s_globalTable[ pDynVar->hMemvar ].pVarItem->item.asLogical.value = TRUE;
else
s_globalTable[ pDynVar->hMemvar ].pVarItem->item.asLogical.value = FALSE;
}
}
}
else
{
/* We need to store the handle to the value of variable that is
* visible at this moment so later we can restore this value when
* the new variable will be released
*/
pDynVar->hMemvar = hb_memvarValueNew( pValue, pDynVar->hMemvar );
/* Add this variable to the PRIVATE variables stack
*/
hb_memvarAddPrivate( pDynVar );
}
}
/* This function releases all memory occupied by a memvar variable
* It also restores the value that was hidden if there is another
* PRIVATE variable with the same name.
*/
static void hb_memvarRelease( HB_ITEM_PTR pMemvar )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarRelease(%p)", pMemvar));
if( HB_IS_STRING( pMemvar ) )
{
PHB_DYNS pDynSymbol = hb_memvarFindSymbol( pMemvar->item.asString.value,
pMemvar->item.asString.length );
if( pDynSymbol && pDynSymbol->hMemvar )
{
ULONG ulBase = s_privateStackCnt;
/* Find the variable with a requested name that is currently visible
* Start from the top of the stack.
*/
while( ulBase > 0 )
{
if( pDynSymbol == s_privateStack[ --ulBase ] )
{
/* reset current value to NIL - the overriden variables will be
* visible after exit from current procedure
*/
hb_itemClear( s_globalTable[ pDynSymbol->hMemvar ].pVarItem );
return;
}
}
/* No match found for PRIVATEs - it's PUBLIC so let's remove it.
*/
hb_memvarDetachDynSym( pDynSymbol, FALSE );
}
}
else
hb_errRT_BASE( EG_ARG, 3008, NULL, "RELEASE", HB_ERR_ARGS_BASEPARAMS );
}
/* This function releases all memory occupied by a memvar variable and
* assigns NIL value - it releases variables created in current
* procedure only.
* The scope of released variables are specified using passed name's mask
*/
static void hb_memvarReleaseWithMask( char *szMask, BOOL bInclude )
{
ULONG ulBase = s_privateStackCnt;
PHB_DYNS pDynVar;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarReleaseWithMask(%s, %d)", szMask, (int) bInclude));
while( ulBase > s_privateStackBase )
{
--ulBase;
pDynVar = s_privateStack[ ulBase ];
/* reset current value to NIL - the overriden variables will be
* visible after exit from current procedure
*/
if( pDynVar->hMemvar )
{
BOOL fMatch = hb_strMatchCaseWildExact( pDynVar->pSymbol->szName, szMask );
if( bInclude ? fMatch : !fMatch )
hb_itemClear( s_globalTable[ pDynVar->hMemvar ].pVarItem );
}
}
}
/* Checks if passed dynamic symbol is a variable and returns its scope
*/
static int hb_memvarScopeGet( PHB_DYNS pDynVar )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarScopeGet(%p)", pDynVar));
if( pDynVar->hMemvar == 0 )
return HB_MV_UNKNOWN;
else
{
ULONG ulBase = s_privateStackCnt; /* start from the top of the stack */
while( ulBase )
{
if( pDynVar == s_privateStack[ --ulBase ] )
{
if( ulBase >= s_privateStackBase )
return HB_MV_PRIVATE_LOCAL;
else
return HB_MV_PRIVATE_GLOBAL;
}
}
return HB_MV_PUBLIC;
}
}
/* This function checks the scope of passed variable name
*/
int hb_memvarScope( char * szVarName, ULONG ulLength )
{
PHB_DYNS pDynVar;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarScope(%s, %lu)", szVarName, ulLength));
pDynVar = hb_memvarFindSymbol( szVarName, ulLength );
if( pDynVar )
return hb_memvarScopeGet( pDynVar );
else
return HB_MV_NOT_FOUND;
}
/* Releases memory occupied by a variable
*/
static HB_DYNS_FUNC( hb_memvarClear )
{
HB_SYMBOL_UNUSED( Cargo );
if( pDynSymbol->hMemvar )
hb_memvarDetachDynSym( pDynSymbol, FALSE );
return TRUE;
}
/* Clear all memvar variables */
void hb_memvarsClear( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarsClear()"));
hb_stackClearMevarsBase();
s_privateStackBase = 0;
hb_memvarSetPrivatesBase( 0 );
hb_dynsymEval( hb_memvarClear, NULL );
}
/* Checks passed dynamic symbol if it is a PUBLIC variable and
* increments the counter eventually
*/
static HB_DYNS_FUNC( hb_memvarCountPublics )
{
if( hb_memvarScopeGet( pDynSymbol ) == HB_MV_PUBLIC )
( * ( ( int * )Cargo ) )++;
return TRUE;
}
/* Count the number of variables with given scope
*/
static int hb_memvarCount( int iScope )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarCount(%d)", iScope));
if( iScope == HB_MV_PUBLIC )
{
int iPublicCnt = 0;
hb_dynsymEval( hb_memvarCountPublics, ( void * ) &iPublicCnt );
return iPublicCnt;
}
else
return s_privateStackCnt; /* number of PRIVATE variables */
}
/* Checks passed dynamic symbol if it is a PUBLIC variable and returns
* a pointer to its dynamic symbol
*/
static HB_DYNS_FUNC( hb_memvarFindPublicByPos )
{
BOOL bCont = TRUE;
if( hb_memvarScopeGet( pDynSymbol ) == HB_MV_PUBLIC )
{
struct mv_PUBLIC_var_info *pStruPub = (struct mv_PUBLIC_var_info *) Cargo;
if( pStruPub->iPos-- == 0 )
{
pStruPub->bFound = TRUE;
pStruPub->pDynSym = pDynSymbol;
bCont =FALSE;
}
}
return bCont;
}
/* Returns the pointer to item that holds a value of variable (or NULL if
* not found). It fills also the pointer to the variable name
* Both pointers points to existing and used data - they shouldn't be
* deallocated.
*/
static HB_ITEM_PTR hb_memvarDebugVariable( int iScope, int iPos, const char * * pszName )
{
HB_ITEM_PTR pValue = NULL;
*pszName = NULL;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarDebugVariable(%d, %d, %p)", iScope, iPos, pszName));
if( iPos > 0 )
{
--iPos;
if( iScope == HB_MV_PUBLIC )
{
struct mv_PUBLIC_var_info struPub;
struPub.iPos = iPos;
struPub.bFound = FALSE;
/* enumerate existing dynamic symbols and fill this structure
* with info for requested PUBLIC variable
*/
hb_dynsymEval( hb_memvarFindPublicByPos, ( void * ) &struPub );
if( struPub.bFound )
{
pValue = s_globalTable[ struPub.pDynSym->hMemvar ].pVarItem;
*pszName = struPub.pDynSym->pSymbol->szName;
}
}
else
{
if( ( ULONG ) iPos < s_privateStackCnt )
{
HB_DYNS_PTR pDynSym = s_privateStack[ iPos ];
pValue =s_globalTable[ pDynSym->hMemvar ].pVarItem;
*pszName = pDynSym->pSymbol->szName;
}
}
}
return pValue;
}
/* ************************************************************************** */
static char * hb_memvarGetMask( int iParam )
{
char * pszMask = hb_parc( iParam );
if( !pszMask || pszMask[ 0 ] == '*' )
pszMask = "*";
return pszMask;
}
HB_FUNC( __MVPUBLIC )
{
int iCount = hb_pcount();
if( iCount )
{
int i;
for( i = 1; i <= iCount; i++ )
{
PHB_ITEM pMemvar = hb_param( i, HB_IT_ANY );
if( pMemvar )
{
if( HB_IS_ARRAY( pMemvar ) )
{
/* we are accepting an one-dimensional array of strings only
*/
ULONG j, ulLen = hb_arrayLen( pMemvar );
for( j = 1; j <= ulLen; j++ )
{
hb_memvarCreateFromItem( hb_arrayGetItemPtr( pMemvar, j ), VS_PUBLIC, NULL );
}
}
else
hb_memvarCreateFromItem( pMemvar, VS_PUBLIC, NULL );
}
}
}
}
HB_FUNC( __MVPRIVATE )
{
int iCount = hb_pcount();
if( iCount )
{
int i;
for( i = 1; i <= iCount; i++ )
{
PHB_ITEM pMemvar = hb_param( i, HB_IT_ANY );
if( pMemvar )
{
if( HB_IS_ARRAY( pMemvar ) )
{
/* we are accepting an one-dimensional array of strings only
*/
ULONG j, ulLen = hb_arrayLen( pMemvar );
for( j = 1; j <= ulLen; j++ )
{
hb_memvarCreateFromItem( hb_arrayGetItemPtr( pMemvar, j ), VS_PRIVATE, NULL );
}
}
else
hb_memvarCreateFromItem( pMemvar, VS_PRIVATE, NULL );
}
}
hb_memvarUpdatePrivatesBase();
}
}
HB_FUNC( __MVXRELEASE )
{
int iCount = hb_pcount();
if( iCount )
{
int i;
for( i = 1; i <= iCount; i++ )
{
PHB_ITEM pMemvar = hb_param( i, HB_IT_ANY );
if( pMemvar )
{
if( HB_IS_ARRAY( pMemvar ) )
{
/* we are accepting an one-dimensional array of strings only
*/
ULONG j, ulLen = hb_arrayLen( pMemvar );
for( j = 1; j <= ulLen; j++ )
{
hb_memvarRelease( hb_arrayGetItemPtr( pMemvar, j ) );
}
}
else
hb_memvarRelease( pMemvar );
}
}
}
}
HB_FUNC( __MVRELEASE )
{
int iCount = hb_pcount();
if( iCount && ISCHAR( 1 ) )
{
BOOL bIncludeVar;
char * pszMask;
pszMask = hb_memvarGetMask( 1 );
bIncludeVar = ( pszMask[ 0 ] == '*' && !pszMask[ 1 ] ) ||
iCount < 2 || hb_parl( 2 );
hb_memvarReleaseWithMask( pszMask, bIncludeVar );
}
}
HB_FUNC( __MVSCOPE )
{
int iMemvar = HB_MV_ERROR;
if( hb_pcount() )
{
PHB_ITEM pVarName = hb_param( 1, HB_IT_STRING );
if( pVarName )
iMemvar = hb_memvarScope( pVarName->item.asString.value,
pVarName->item.asString.length );
}
hb_retni( iMemvar );
}
HB_FUNC( __MVCLEAR )
{
hb_memvarsClear();
}
HB_FUNC( __MVDBGINFO )
{
int iCount = hb_pcount();
if( iCount == 1 ) /* request for a number of variables */
hb_retni( hb_memvarCount( hb_parni( 1 ) ) );
else if( iCount >= 2 ) /* request for a value of variable */
{
HB_ITEM_PTR pValue;
const char * szName;
pValue = hb_memvarDebugVariable( hb_parni( 1 ), hb_parni( 2 ), &szName );
if( pValue )
{
/*the requested variable was found
*/
if( iCount >= 3 && ISBYREF( 3 ) )
{
/* we have to use this variable regardless of its current value
*/
HB_ITEM_PTR pName = hb_param( 3, HB_IT_ANY );
hb_itemPutC( pName, szName ); /* clear an old value and copy a new one */
/* szName points directly to a symbol name - it cannot be released
*/
}
hb_itemReturn( pValue );
/* pValue points directly to the item structure used by this variable
* this item cannot be released
*/
}
else
{
hb_ret(); /* return NIL value */
if( iCount >= 3 && ISBYREF( 3 ) )
{
/* we have to use this variable regardless of its current value
*/
HB_ITEM_PTR pName = hb_param( 3, HB_IT_ANY );
hb_itemPutC( pName, "?" ); /* clear an old value and copy a new one */
}
}
}
}
HB_FUNC( __MVEXIST )
{
PHB_DYNS pDyn;
pDyn = hb_memvarFindSymbol( hb_parc( 1 ), hb_parclen( 1 ) );
hb_retl( pDyn && pDyn->hMemvar );
}
HB_FUNC( __MVGET )
{
HB_ITEM_PTR pName = hb_param( 1, HB_IT_STRING );
if( pName )
{
HB_DYNS_PTR pDynVar = hb_memvarFindSymbol( pName->item.asString.value,
pName->item.asString.length );
if( pDynVar )
{
PHB_ITEM pValue = hb_stackAllocItem();
hb_memvarGetValue( pValue, pDynVar->pSymbol );
hb_itemReturnForward( pValue );
hb_stackDec();
}
else
{
/* Generate an error with retry possibility
* (user created error handler can create this variable)
*/
HB_ITEM_PTR pError;
pError = hb_errRT_New( ES_ERROR, NULL, EG_NOVAR, 1003,
NULL, pName->item.asString.value, 0, EF_CANRETRY );
while( hb_errLaunch( pError ) == E_RETRY )
{
pDynVar = hb_memvarFindSymbol( hb_itemGetCPtr( pName ),
hb_itemGetCLen( pName ) );
if( pDynVar )
{
PHB_ITEM pValue = hb_stackAllocItem();
hb_memvarGetValue( pValue, pDynVar->pSymbol );
hb_itemReturnForward( pValue );
hb_stackDec();
break;
}
}
hb_errRelease( pError );
}
}
else
{
/* either the first parameter is not specified or it has a wrong type
* (it must be a string)
* This is not a critical error - we can continue normal processing
*/
hb_errRT_BASE_SubstR( EG_ARG, 3009, NULL, NULL, HB_ERR_ARGS_BASEPARAMS );
}
}
HB_FUNC( __MVPUT )
{
HB_ITEM_PTR pName = hb_param( 1, HB_IT_STRING );
HB_ITEM_PTR pValue = hb_paramError( 2 );
if( pName )
{
/* the first parameter is a string with not empty variable name
*/
HB_DYNS_PTR pDynVar = hb_memvarFindSymbol( pName->item.asString.value,
pName->item.asString.length );
if( pDynVar )
{
/* variable was declared somwhere - assign a new value
*/
hb_memvarSetValue( pDynVar->pSymbol, pValue );
}
else
{
/* attempt to assign a value to undeclared variable
* create the PRIVATE one
*/
hb_memvarCreateFromDynSymbol( hb_dynsymGet( pName->item.asString.value ), VS_PRIVATE, pValue );
}
hb_memvarUpdatePrivatesBase();
hb_itemReturn( pValue );
}
else
{
/* either the first parameter is not specified or it has a wrong type
* (it must be a string)
* This is not a critical error - we can continue normal processing
*/
HB_ITEM_PTR pRetValue = hb_errRT_BASE_Subst( EG_ARG, 3010, NULL, NULL, HB_ERR_ARGS_BASEPARAMS );
if( pRetValue )
hb_itemRelease( pRetValue );
hb_itemReturn( pValue );
}
}
#define HB_MEM_REC_LEN 32
#define HB_MEM_NUM_LEN 8
typedef struct
{
char * pszMask;
BOOL bIncludeMask;
BYTE * buffer;
FHANDLE fhnd;
} MEMVARSAVE_CARGO;
/* saves a variable to a mem file already open */
static HB_DYNS_FUNC( hb_memvarSave )
{
char * pszMask = ( ( MEMVARSAVE_CARGO * ) Cargo )->pszMask;
BOOL bIncludeMask = ( ( MEMVARSAVE_CARGO * ) Cargo )->bIncludeMask;
BYTE * buffer = ( ( MEMVARSAVE_CARGO * ) Cargo )->buffer;
FHANDLE fhnd = ( ( MEMVARSAVE_CARGO * ) Cargo )->fhnd;
/* NOTE: Harbour name lengths are not limited, but the .mem file
structure is not flexible enough to allow for it.
[vszakats] */
if( pDynSymbol->hMemvar )
{
BOOL bMatch = hb_strMatchCaseWildExact( pDynSymbol->pSymbol->szName, pszMask );
PHB_ITEM pItem = s_globalTable[ pDynSymbol->hMemvar ].pVarItem;
/* Process it if it matches the passed mask */
if( bIncludeMask ? bMatch : ! bMatch )
{
/* NOTE: Clipper will not initialize the record buffer with
zeros, so they will look trashed. [vszakats] */
memset( buffer, 0, HB_MEM_REC_LEN );
/* NOTE: Save only the first 10 characters of the name */
strncpy( ( char * ) buffer, pDynSymbol->pSymbol->szName, 10 );
buffer[ 10 ] = '\0';
if( HB_IS_STRING( pItem ) && ( hb_itemGetCLen( pItem ) + 1 ) <= SHRT_MAX )
{
/* Store the closing zero byte, too */
USHORT uiLength = ( USHORT ) ( hb_itemGetCLen( pItem ) + 1 );
buffer[ 11 ] = 'C' + 128;
buffer[ 16 ] = HB_LOBYTE( uiLength );
buffer[ 17 ] = HB_HIBYTE( uiLength );
hb_fsWrite( fhnd, buffer, HB_MEM_REC_LEN );
hb_fsWrite( fhnd, ( BYTE * ) hb_itemGetCPtr( pItem ), uiLength );
}
else if( HB_IS_NUMERIC( pItem ) )
{
BYTE byNum[ sizeof( double ) ];
int iWidth;
int iDec;
hb_itemGetNLen( pItem, &iWidth, &iDec );
buffer[ 11 ] = 'N' + 128;
#ifdef HB_C52_STRICT
/* NOTE: This is the buggy, but fully CA-Cl*pper compatible method. [vszakats] */
buffer[ 16 ] = ( BYTE ) iWidth + ( HB_IS_DOUBLE( pItem ) ? iDec + 1 : 0 );
#else
/* NOTE: This would be the correct method, but Clipper is buggy here. [vszakats] */
buffer[ 16 ] = ( BYTE ) iWidth + ( iDec == 0 ? 0 : iDec + 1 );
#endif
buffer[ 17 ] = ( BYTE ) iDec;
HB_PUT_LE_DOUBLE( byNum, hb_itemGetND( pItem ) );
hb_fsWrite( fhnd, buffer, HB_MEM_REC_LEN );
hb_fsWrite( fhnd, byNum, sizeof( byNum ) );
}
else if( HB_IS_DATE( pItem ) )
{
BYTE byNum[ sizeof( double ) ];
double dNumber = ( double ) hb_itemGetDL( pItem );
buffer[ 11 ] = 'D' + 128;
buffer[ 16 ] = 1;
buffer[ 17 ] = 0;
HB_PUT_LE_DOUBLE( byNum, dNumber );
hb_fsWrite( fhnd, buffer, HB_MEM_REC_LEN );
hb_fsWrite( fhnd, byNum, sizeof( byNum ) );
}
else if( HB_IS_LOGICAL( pItem ) )
{
BYTE byLogical[ 1 ];
buffer[ 11 ] = 'L' + 128;
buffer[ 16 ] = sizeof( BYTE );
buffer[ 17 ] = 0;
byLogical[ 0 ] = hb_itemGetL( pItem ) ? 1 : 0;
hb_fsWrite( fhnd, buffer, HB_MEM_REC_LEN );
hb_fsWrite( fhnd, byLogical, sizeof( BYTE ) );
}
}
}
return TRUE;
}
HB_FUNC( __MVSAVE )
{
/* Clipper also checks for the number of arguments here */
if( hb_pcount() == 3 && ISCHAR( 1 ) && ISCHAR( 2 ) && ISLOG( 3 ) )
{
PHB_FNAME pFileName;
char szFileName[ _POSIX_PATH_MAX + 1 ];
FHANDLE fhnd;
/* Generate filename */
pFileName = hb_fsFNameSplit( hb_parc( 1 ) );
if( hb_set.HB_SET_DEFEXTENSIONS && pFileName->szExtension == NULL )
pFileName->szExtension = ".mem";
if( pFileName->szPath == NULL )
pFileName->szPath = hb_set.HB_SET_DEFAULT;
hb_fsFNameMerge( szFileName, pFileName );
hb_xfree( pFileName );
/* Create .mem file */
do
{
fhnd = hb_fsCreate( ( BYTE * ) szFileName, FC_NORMAL );
}
#ifdef HB_C52_STRICT
while( fhnd == FS_ERROR &&
hb_errRT_BASE_Ext1( EG_CREATE, 2006, NULL, szFileName,
hb_fsError(), EF_CANDEFAULT | EF_CANRETRY,
0 ) == E_RETRY );
#else
while( fhnd == FS_ERROR &&
hb_errRT_BASE_Ext1( EG_CREATE, 2006, NULL, szFileName,
hb_fsError(), EF_CANDEFAULT | EF_CANRETRY,
HB_ERR_ARGS_BASEPARAMS ) == E_RETRY );
#endif
if( fhnd != FS_ERROR )
{
BYTE buffer[ HB_MEM_REC_LEN ];
MEMVARSAVE_CARGO msc;
msc.pszMask = hb_memvarGetMask( 2 );
msc.bIncludeMask = hb_parl( 3 );
msc.buffer = buffer;
msc.fhnd = fhnd;
/* Walk through all visible memory variables and save each one */
hb_dynsymEval( hb_memvarSave, ( void * ) &msc );
buffer[ 0 ] = '\x1A';
hb_fsWrite( fhnd, buffer, 1 );
hb_fsClose( fhnd );
}
}
else
/* NOTE: Undocumented error message in CA-Cl*pper 5.2e and 5.3x. [ckedem] */
hb_errRT_BASE( EG_ARG, 2008, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
/* NOTE: There's an extension in Harbour, which makes it possible to only
load (or not load) variable names with a specific name mask.
[vszakats] */
HB_FUNC( __MVRESTORE )
{
/* Clipper checks for the number of arguments here here, but we cannot
in Harbour since we have two optional parameters as an extension. */
#ifdef HB_C52_STRICT
if( hb_pcount() == 2 && ISCHAR( 1 ) && ISLOG( 2 ) )
#else
if( ISCHAR( 1 ) && ISLOG( 2 ) )
#endif
{
PHB_FNAME pFileName;
char szFileName[ _POSIX_PATH_MAX + 1 ];
FHANDLE fhnd;
BOOL bAdditive = hb_parl( 2 );
/* Clear all memory variables if not ADDITIVE */
if( ! bAdditive )
hb_memvarsClear();
/* Generate filename */
pFileName = hb_fsFNameSplit( hb_parc( 1 ) );
if( hb_set.HB_SET_DEFEXTENSIONS && pFileName->szExtension == NULL )
pFileName->szExtension = ".mem";
if( pFileName->szPath == NULL )
pFileName->szPath = hb_set.HB_SET_DEFAULT;
hb_fsFNameMerge( szFileName, pFileName );
hb_xfree( pFileName );
/* Open .mem file */
do
{
fhnd = hb_fsOpen( ( BYTE * ) szFileName, FO_READ | FO_DENYWRITE | FO_PRIVATE );
}
#ifdef HB_C52_STRICT
while( fhnd == FS_ERROR &&
hb_errRT_BASE_Ext1( EG_OPEN, 2005, NULL, szFileName,
hb_fsError(), EF_CANDEFAULT | EF_CANRETRY,
0 ) == E_RETRY );
#else
while( fhnd == FS_ERROR &&
hb_errRT_BASE_Ext1( EG_OPEN, 2005, NULL, szFileName,
hb_fsError(), EF_CANDEFAULT | EF_CANRETRY,
HB_ERR_ARGS_BASEPARAMS ) == E_RETRY );
#endif
if( fhnd != FS_ERROR )
{
BOOL bIncludeMask;
BYTE buffer[ HB_MEM_REC_LEN ];
char * pszMask;
#ifdef HB_C52_STRICT
pszMask = "*";
bIncludeMask = TRUE;
#else
pszMask = hb_memvarGetMask( 3 );
bIncludeMask = !ISLOG( 4 ) || hb_parl( 4 );
#endif
while( hb_fsRead( fhnd, buffer, HB_MEM_REC_LEN ) == HB_MEM_REC_LEN )
{
char *szName = hb_strdup( ( char * ) buffer );
USHORT uiType = ( USHORT ) ( buffer[ 11 ] - 128 );
USHORT uiWidth = ( USHORT ) buffer[ 16 ];
USHORT uiDec = ( USHORT ) buffer[ 17 ];
PHB_ITEM pItem = NULL;
switch( uiType )
{
case 'C':
{
BYTE * pbyString;
uiWidth += uiDec * 256;
pbyString = ( BYTE * ) hb_xgrab( uiWidth );
if( hb_fsRead( fhnd, pbyString, uiWidth ) == uiWidth )
pItem = hb_itemPutCL( NULL, ( char * ) pbyString, uiWidth - 1 );
hb_xfree( pbyString );
break;
}
case 'N':
{
BYTE pbyNumber[ HB_MEM_NUM_LEN ];
if( hb_fsRead( fhnd, pbyNumber, HB_MEM_NUM_LEN ) == HB_MEM_NUM_LEN )
pItem = hb_itemPutNLen( NULL, HB_GET_LE_DOUBLE( pbyNumber ), uiWidth - ( uiDec ? ( uiDec + 1 ) : 0 ), uiDec );
break;
}
case 'D':
{
BYTE pbyNumber[ HB_MEM_NUM_LEN ];
if( hb_fsRead( fhnd, pbyNumber, HB_MEM_NUM_LEN ) == HB_MEM_NUM_LEN )
pItem = hb_itemPutDL( NULL, ( long ) HB_GET_LE_DOUBLE( pbyNumber ) );
break;
}
case 'L':
{
BYTE pbyLogical[ 1 ];
if( hb_fsRead( fhnd, pbyLogical, 1 ) == 1 )
pItem = hb_itemPutL( NULL, pbyLogical[ 0 ] != 0 );
break;
}
}
if( pItem )
{
BOOL bMatch = hb_strMatchCaseWildExact( szName, pszMask );
/* Process it if it matches the passed mask */
if( bIncludeMask ? bMatch : ! bMatch )
{
/* the first parameter is a string with not empty variable name */
HB_DYNS_PTR pDynVar = hb_memvarFindSymbol( szName, strlen( szName ) );
if( pDynVar )
/* variable was declared somwhere - assign a new value */
hb_memvarSetValue( pDynVar->pSymbol, pItem );
else
/* attempt to assign a value to undeclared variable create the PRIVATE one */
hb_memvarCreateFromDynSymbol( hb_dynsymGet( szName ), VS_PRIVATE, pItem );
hb_itemReturn( pItem );
}
hb_itemRelease( pItem );
}
hb_xfree( szName );
}
hb_fsClose( fhnd );
hb_memvarUpdatePrivatesBase();
}
else
hb_retl( FALSE );
}
else
/* NOTE: Undocumented error message in CA-Cl*pper 5.2e and 5.3x. [ckedem] */
hb_errRT_BASE( EG_ARG, 2007, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
/*
* This is a hacking function which changes base private offset so
* PRIVATE variables created in function which calls __MVSETBASE()
* will not be released when the function exit but will be inherited
* by its caller. [druzus]
*/
HB_FUNC( __MVSETBASE )
{
long lOffset = hb_stackBaseProcOffset( 0 );
if( lOffset > 0 )
hb_stackItem( lOffset )->item.asSymbol.stackstate->ulPrivateBase =
hb_memvarGetPrivatesBase();
}
/* ----------------------------------------------------------------------- */
/* The garbage collector interface */
/* ----------------------------------------------------------------------- */
/* Mark all memvars as used so they will not be released by the
* garbage collector
*/
void hb_memvarsIsMemvarRef( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarsIsMemvarRef()"));
if( s_globalTable )
{
ULONG ulCnt = s_globalLastFree;
while( --ulCnt )
{
/* do not check detached variables - for these variables only
* references from the eval stack are meaningfull for the GC
*/
if( s_globalTable[ ulCnt ].counter && s_globalTable[ ulCnt ].hPrevMemvar != ( HB_HANDLE )-1 )
{
if( HB_IS_GCITEM( s_globalTable[ ulCnt ].pVarItem ) )
hb_gcItemRef( s_globalTable[ ulCnt ].pVarItem );
}
}
}
}
HB_HANDLE hb_memvarGetVarHandle( char *szName )
{
PHB_DYNS pDyn;
if( ( pDyn = hb_dynsymFind( szName ) ) != NULL )
return pDyn->hMemvar;
else
return 0; /* invalid handle */
}
PHB_ITEM hb_memvarGetValueByHandle( HB_HANDLE hMemvar )
{
if( hMemvar && hMemvar < s_globalTableSize )
return s_globalTable[ hMemvar ].pVarItem;
else
return NULL;
}
Reference in New Issue View Git Blame Copy Permalink