fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial revision

Browse Source
This commit is contained in:
Ryszard Glab
2000-12-12 20:16:33 +00:00
parent bd23343fdb
commit cae8dad460
2 changed files with 533 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
harbour/include/hbstack.h Normal file
View File

@@ -0,0 +1,112 @@
/*
* $Id$
*/
/*
* Harbour Project source code:
* The eval stack
*
* Copyright 1999 Antonio Linares <alinares@fivetech.com>
* 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 of the License, or
* (at your option) any later version, with one exception:
*
* The exception is that if you link the Harbour Runtime Library (HRL)
* and/or the Harbour Virtual Machine (HVM) 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 HRL
* and/or HVM code into it.
*
* 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 (or visit
* their web site at http://www.gnu.org/).
*
*/
/* TOFIX: There are several things in this file which are not part of the
standard Harbour API, in other words these things are not
guaranteed to remain unchanged. To avoid confusion these should be
moved to somewhere else (like HBRTL.H). [vszakats] */
#ifndef HB_STACK_H_
#define HB_STACK_H_
#include "hbvmpub.h"
#if defined(HB_EXTERN_C)
extern "C" {
#endif
/* stack managed by the virtual machine */
typedef struct
{
PHB_ITEM * pItems; /* pointer to the stack items */
PHB_ITEM * pPos; /* pointer to the latest used item */
LONG wItems; /* total items that may be holded on the stack */
HB_ITEM Return; /* latest returned value */
PHB_ITEM * pBase; /* stack frame position for the current function call */
PHB_ITEM * pEvalBase; /* stack frame position for the evaluated codeblock */
int iStatics; /* statics base for the current function call */
char szDate[ 9 ]; /* last returned date from _pards() yyyymmdd format */
} HB_STACK;
extern HB_STACK hb_stack;
typedef struct
{
LONG lBaseItem;
LONG iStatics;
} HB_STACK_STATE; /* used to save/restore stack state in hb_vmDo)_ */
#if defined(HB_STACK_MACROS)
#define hb_stackItemFromTop( n ) ( * ( hb_stack->pPos + (n) ) )
#define hb_stackItemFromBase( n ) ( * ( hb_stack->pBase + (n) + 1 ) )
#define hb_stackTopOffset( ) ( hb_stack.pPos - hb_stack.pItems )
#define hb_stackBaseOffset( ) ( hb_stack.pBase - hb_stack.pItems + )
#define hb_stackTopItem( ) ( * hb_stack.pPos )
#define hb_stackBaseItem( ) ( * hb_stack.pBase )
#define hb_stackSelfItem( ) ( * ( hb_stack.pBase + 1 ) )
#define hb_stackItem( iItemPos ) ( * ( hb_stack.pItems + iItemPos ) )
#else
extern HB_ITEM_PTR hb_stackItemFromTop( int nFromTop );
extern HB_ITEM_PTR hb_stackItemFromBase( int nFromBase );
extern LONG hb_stackTopOffset( void );
extern LONG hb_stackBaseOffset( void );
extern HB_ITEM_PTR hb_stackTopItem( void );
extern HB_ITEM_PTR hb_stackBaseItem( void );
extern HB_ITEM_PTR hb_stackSelfItem( void );
extern HB_ITEM_PTR hb_stackItem( LONG iItemPos );
#endif
extern void hb_stackRemove( LONG lUntilPos );
extern HB_ITEM_PTR hb_stackNewFrame( HB_STACK_STATE * pStack, USHORT uiParams );
extern void hb_stackOldFrame( HB_STACK_STATE * pStack );
/* stack management functions */
extern void hb_stackDispLocal( void ); /* show the types of the items on the stack for debugging purposes */
extern void hb_stackDispCall( void );
extern void hb_stackDec( void ); /* pops an item from the stack without clearing it's contents */
extern void hb_stackFree( void ); /* releases all memory used by the stack */
extern void hb_stackPush( void ); /* pushes an item on to the stack */
extern void hb_stackPop( void ); /* pops an item from the stack */
extern void hb_stackInit( void ); /* initializes the stack */
#if defined(HB_EXTERN_C)
}
#endif
#endif /* HB_STACK_H_ */

421
harbour/source/vm/estack.c Normal file
View File

@@ -0,0 +1,421 @@
/*
* $Id$
*/
/*
* Harbour Project source code:
* The eval stack management functions
*
* Copyright 1999 Antonio Linares <alinares@fivetech.com>
* 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 of the License, or
* (at your option) any later version, with one exception:
*
* The exception is that if you link the Harbour Runtime Library (HRL)
* and/or the Harbour Virtual Machine (HVM) 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 HRL
* and/or HVM code into it.
*
* 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 (or visit
* their web site at http://www.gnu.org/).
*
*/
#include "hbapi.h"
#include "hbstack.h"
#include "hbapiitm.h"
#include "hbapierr.h"
/* ------------------------------- */
#define STACK_INITHB_ITEMS 2000
#define STACK_EXPANDHB_ITEMS 200
HB_STACK hb_stack;
/* ------------------------------- */
void hb_stackPop( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_stackPop()"));
if( --hb_stack.pPos < hb_stack.pItems )
hb_errInternal( HB_EI_STACKUFLOW, NULL, NULL, NULL );
if( ( * hb_stack.pPos )->type != HB_IT_NIL )
hb_itemClear( * hb_stack.pPos );
}
void hb_stackDec( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_stackDec()"));
if( --hb_stack.pPos < hb_stack.pItems )
hb_errInternal( HB_EI_STACKUFLOW, NULL, NULL, NULL );
}
void hb_stackFree( void )
{
LONG i;
HB_TRACE(HB_TR_DEBUG, ("hb_stackFree()"));
i = hb_stack.wItems - 1;
while( i >= 0 )
hb_xfree( hb_stack.pItems[ i-- ] );
hb_xfree( hb_stack.pItems );
}
void hb_stackPush( void )
{
LONG CurrIndex; /* index of current top item */
LONG TopIndex; /* index of the topmost possible item */
LONG i;
HB_TRACE(HB_TR_DEBUG, ("hb_stackPush()"));
CurrIndex = hb_stack.pPos - hb_stack.pItems;
TopIndex = hb_stack.wItems - 1;
/* enough room for another item ? */
if( !( TopIndex > CurrIndex ) )
{
LONG BaseIndex; /* index of stack base */
BaseIndex = hb_stack.pBase - hb_stack.pItems;
/* no, make more headroom: */
/* hb_stackDispLocal(); */
hb_stack.pItems = ( HB_ITEM_PTR * ) hb_xrealloc( ( void *)hb_stack.pItems, sizeof( HB_ITEM_PTR ) *
( hb_stack.wItems + STACK_EXPANDHB_ITEMS ) );
/* fix possibly invalid pointers: */
hb_stack.pPos = hb_stack.pItems + CurrIndex;
hb_stack.pBase = hb_stack.pItems + BaseIndex;
hb_stack.wItems += STACK_EXPANDHB_ITEMS;
for( i=CurrIndex; i < hb_stack.wItems; ++i )
hb_stack.pItems[ i ] = hb_xgrab( sizeof( HB_ITEM ) );
/* hb_stackDispLocal(); */
}
/* now, push it: */
hb_stack.pPos++;
( * hb_stack.pPos )->type = HB_IT_NIL;
}
void hb_stackInit( void )
{
ULONG i;
HB_TRACE(HB_TR_DEBUG, ("hb_stackInit()"));
hb_stack.pItems = ( HB_ITEM_PTR * ) hb_xgrab( sizeof( HB_ITEM_PTR ) * STACK_INITHB_ITEMS );
hb_stack.pBase = hb_stack.pItems;
hb_stack.pPos = hb_stack.pItems; /* points to the first stack item */
hb_stack.wItems = STACK_INITHB_ITEMS;
for( i=0; i < hb_stack.wItems; ++i )
hb_stack.pItems[ i ] = hb_xgrab( sizeof( HB_ITEM ) );
}
void hb_stackRemove( LONG lUntilPos )
{
HB_ITEM_PTR * pEnd = hb_stack.pItems + lUntilPos;
while( hb_stack.pPos > pEnd )
hb_stackPop();
}
HB_ITEM_PTR hb_stackNewFrame( HB_STACK_STATE * pStack, USHORT uiParams )
{
HB_ITEM_PTR pItem;
pItem = hb_stackItemFromTop( - uiParams - 2 ); /* procedure name */
if( ! HB_IS_SYMBOL( pItem ) )
{
/* QUESTION: Is this call needed ? [vszakats] */
hb_stackDispLocal();
hb_errInternal( HB_EI_VMNOTSYMBOL, NULL, "hb_vmDo()", NULL );
}
pStack->lBaseItem = hb_stack.pBase - hb_stack.pItems;
pStack->iStatics = hb_stack.iStatics;
pItem->item.asSymbol.lineno = 0;
pItem->item.asSymbol.paramcnt = uiParams;
hb_stack.pBase = hb_stack.pItems + pItem->item.asSymbol.stackbase;
pItem->item.asSymbol.stackbase = pStack->lBaseItem;
return pItem;
}
void hb_stackOldFrame( HB_STACK_STATE * pStack )
{
while( hb_stack.pPos > hb_stack.pBase )
hb_stackPop();
hb_stack.pBase = hb_stack.pItems + pStack->lBaseItem;
hb_stack.iStatics = pStack->iStatics;
}
#if !defined(HB_STACK_MACROS)
HB_ITEM_PTR hb_stackItem( LONG iItemPos )
{
if( iItemPos < 0 )
hb_errInternal( HB_EI_STACKUFLOW, NULL, NULL, NULL );
return ( * ( hb_stack.pItems + iItemPos ) );
}
HB_ITEM_PTR hb_stackItemFromTop( int nFromTop )
{
if( nFromTop > 0 )
hb_errInternal( HB_EI_STACKUFLOW, NULL, NULL, NULL );
return ( * ( hb_stack.pPos + nFromTop ) );
}
HB_ITEM_PTR hb_stackItemFromBase( int nFromBase )
{
if( nFromBase <= 0 )
hb_errInternal( HB_EI_STACKUFLOW, NULL, NULL, NULL );
return ( * ( hb_stack.pBase + nFromBase + 1 ) );
}
HB_ITEM_PTR hb_stackTopItem( void )
{
return * hb_stack.pPos;
}
HB_ITEM_PTR hb_stackBaseItem( void )
{
return * hb_stack.pBase;
}
/* Returns SELF object, an evaluated codeblock or NIL for normal func/proc
*/
HB_ITEM_PTR hb_stackSelfItem( void )
{
return * ( hb_stack.pBase + 1 );
}
LONG hb_stackTopOffset( void )
{
return hb_stack.pPos - hb_stack.pItems;
}
LONG hb_stackBaseOffset( void )
{
return hb_stack.pBase - hb_stack.pItems + 1;
}
#endif
/* NOTE: DEBUG function */
void hb_stackDispLocal( void )
{
PHB_ITEM * pBase;
HB_TRACE(HB_TR_DEBUG, ("hb_stackDispLocal()"));
printf( hb_conNewLine() );
printf( "Virtual Machine Stack Dump at %s(%i):", ( *(hb_stack.pBase) )->item.asSymbol.value->szName, ( *(hb_stack.pBase) )->item.asSymbol.lineno );
printf( hb_conNewLine() );
printf( "--------------------------" );
for( pBase = hb_stack.pBase; pBase <= hb_stack.pPos; pBase++ )
{
printf( hb_conNewLine() );
switch( hb_itemType( *pBase ) )
{
case HB_IT_NIL:
printf( "NIL " );
break;
case HB_IT_ARRAY:
if( hb_arrayIsObject( *pBase ) )
printf( "OBJECT = %s ", hb_objGetClsName( *pBase ) );
else
printf( "ARRAY " );
break;
case HB_IT_BLOCK:
printf( "BLOCK " );
break;
case HB_IT_DATE:
{
char szDate[ 9 ];
printf( "DATE = \"%s\" ", hb_itemGetDS( *pBase, szDate ) );
}
break;
case HB_IT_DOUBLE:
printf( "DOUBLE = %f ", hb_itemGetND( *pBase ) );
break;
case HB_IT_LOGICAL:
printf( "LOGICAL = %s ", hb_itemGetL( *pBase ) ? ".T." : ".F." );
break;
case HB_IT_LONG:
printf( "LONG = %lu ", hb_itemGetNL( *pBase ) );
break;
case HB_IT_INTEGER:
printf( "INTEGER = %i ", hb_itemGetNI( *pBase ) );
break;
case HB_IT_STRING:
printf( "STRING = \"%s\" ", hb_itemGetCPtr( *pBase ) );
break;
case HB_IT_SYMBOL:
printf( "SYMBOL = %s ", ( *pBase )->item.asSymbol.value->szName );
break;
default:
printf( "UNKNOWN = TYPE %i ", hb_itemType( *pBase ) );
break;
}
}
}
void hb_stackDispCall( void )
{
PHB_ITEM * pBase = hb_stack.pBase;
HB_TRACE(HB_TR_DEBUG, ("hb_stackDispCall()"));
while( pBase != hb_stack.pItems )
{
char buffer[ HB_SYMBOL_NAME_LEN + HB_SYMBOL_NAME_LEN + 32 ];
pBase = hb_stack.pItems + ( *pBase )->item.asSymbol.stackbase;
if( ( *( pBase + 1 ) )->type == HB_IT_ARRAY )
sprintf( buffer, "Called from %s:%s(%i)", hb_objGetClsName( *(pBase + 1) ),
( *pBase )->item.asSymbol.value->szName,
( *pBase )->item.asSymbol.lineno );
else
sprintf( buffer, "Called from %s(%i)",
( *pBase )->item.asSymbol.value->szName,
( *pBase )->item.asSymbol.lineno );
hb_conOutErr( buffer, 0 );
hb_conOutErr( hb_conNewLine(), 0 );
}
}
/* ------------------------------------------------------------------------ */
/* The garbage collector interface */
/* ------------------------------------------------------------------------ */
/* Mark all locals as used so they will not be released by the
* garbage collector
*/
void hb_vmIsLocalRef( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmIsLocalRef()"));
if( hb_stack.pPos > hb_stack.pItems )
{
/* the eval stack is not cleared yet */
HB_ITEM_PTR * pItem = hb_stack.pPos - 1;
while( pItem != hb_stack.pItems )
{
if( ( *pItem )->type & (HB_IT_BYREF | HB_IT_ARRAY | HB_IT_BLOCK) )
hb_gcItemRef( *pItem );
--pItem;
}
}
}
#ifdef HB_INCLUDE_WINEXCHANDLER
WINBASEAPI LONG WINAPI UnhandledExceptionFilter( struct _EXCEPTION_POINTERS * ExceptionInfo )
{
PHB_ITEM *pBase = hb_stack.pBase;
char msg[ ( HB_SYMBOL_NAME_LEN + HB_SYMBOL_NAME_LEN + 32 ) * 32 ];
HB_SYMBOL_UNUSED( ExceptionInfo );
msg[ 0 ] = '\0';
do
{
char buffer[ HB_SYMBOL_NAME_LEN + HB_SYMBOL_NAME_LEN + 32 ];
if( ( *( pBase + 1 ) )->type == HB_IT_ARRAY )
sprintf( buffer, "Called from %s:%s(%i)\n", hb_objGetClsName( *(pBase + 1) ),
( *pBase )->item.asSymbol.value->szName,
( *pBase )->item.asSymbol.lineno );
else
sprintf( buffer, "Called from %s(%i)\n",
( *pBase )->item.asSymbol.value->szName,
( *pBase )->item.asSymbol.lineno );
strcat( msg, buffer );
pBase = hb_stack.pItems + ( *pBase )->item.asSymbol.stackbase;
}
while( pBase != hb_stack.pItems )
MessageBox( NULL, msg, "Harbour Exception", MB_ICONSTOP );
return EXCEPTION_EXECUTE_HANDLER; /* EXCEPTION_CONTINUE_SEARCH; */
}
#endif
#if defined(HB_OS_OS2)
ULONG _System OS2TermHandler(PEXCEPTIONREPORTRECORD p1,
PEXCEPTIONREGISTRATIONRECORD p2,
PCONTEXTRECORD p3,
PVOID pv) {
PHB_ITEM *pBase = hb_stack.pBase;
HB_SYMBOL_UNUSED(p1);
HB_SYMBOL_UNUSED(p2);
HB_SYMBOL_UNUSED(p3);
HB_SYMBOL_UNUSED(pv);
/* Don't print stack trace if inside unwind, normal process termination or process killed or
during debugging */
if (p1->ExceptionNum != XCPT_UNWIND && p1->ExceptionNum < XCPT_BREAKPOINT) {
fprintf(stderr, "\nException %lx at address %lx \n", p1->ExceptionNum, (ULONG)p1->ExceptionAddress);
do
{
if( ( *( pBase + 1 ) )->type == HB_IT_ARRAY )
fprintf( stderr, "Called from %s:%s(%i)\n", hb_objGetClsName( *(pBase + 1) ),
( *pBase )->item.asSymbol.value->szName,
( *pBase )->item.asSymbol.lineno );
else
fprintf( stderr, "Called from %s(%i)\n",
( *pBase )->item.asSymbol.value->szName,
( *pBase )->item.asSymbol.lineno );
pBase = hb_stack.pItems + ( *pBase )->item.asSymbol.stackbase;
}
while( pBase != hb_stack.pItems )
}
return XCPT_CONTINUE_SEARCH; /* Exception not resolved... */
}
#endif