fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
dec314f5ba9eaa2c656bf9dcbafc2879d7ed3548
harbour-core/harbour/source/debug/dbgentry.c
Przemyslaw Czerpak dec314f5ba 2007-07-24 14:35 UTC+0200 Przemyslaw Czerpak (druzus/at/priv.onet.pl) 
* harbour/source/debug/dbgentry.c
    ! cleaned memory leak in not freed trap on debugger exit
2007-07-24 12:35:45 +00:00

1772 lines
44 KiB
C
Raw Blame History

/*
* $Id$
*/
/*
* xHarbour Project source code:
* Debugger entry routine
*
* Copyright 2005 Phil Krylov <phil a t newstar.rinet.ru>
* www - http://www.xharbour.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, xHarbour license gives permission for
* additional uses of the text contained in its release of xHarbour.
*
* The exception is that, if you link the xHarbour 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 xHarbour 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 with this xHarbour
* explicit exception. If you add/copy code from other sources,
* as the General Public License permits, the above 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 xHarbour, it is your choice
* whether to permit this exception to apply to your modifications.
* If you do not wish that, delete this exception notice.
*
*/
#include <ctype.h>
#include "hbvmopt.h"
#include "hbapidbg.h"
#include "hbapiitm.h"
#include "hbapirdd.h"
#include "hbstack.h"
#include "hbvm.h"
#include "hbdebug.ch"
#include "hbmacro.ch"
/* dummy function declaration */
static BOOL hb_clsSetScope( BOOL fScope ) { return fScope; }
#if defined( HB_OS_UNIX_COMPATIBLE )
#define FILENAME_EQUAL(s1, s2) ( !strcmp( (s1), (s2) ) )
#else
#define FILENAME_EQUAL(s1, s2) ( !hb_stricmp( (s1), (s2) ) )
#endif
#define ALLOC hb_xgrab
#define FREE hb_xfree
#define STRDUP hb_strdup
#define STRNDUP( dest, source, len ) ( dest = hb_strndup( (source), (len) ) )
#define ARRAY_ADD( type, array, length ) \
( ( ++length == 1 ) ? ( array = ( type * ) hb_xgrab( sizeof( type ) ) ) : \
( ( array = ( type * ) hb_xrealloc( array, sizeof( type ) * length ) ) + \
length - 1 ) )
#define ARRAY_DEL( type, array, length, index ) \
do { \
if ( !--length ) \
hb_xfree( array ); \
else if( index < length ) \
memmove( array + index, array + index + 1, sizeof( type ) * ( length - index ) ); \
} while( 0 )
typedef struct
{
char *szModule;
int nLine;
char *szFunction;
} HB_BREAKPOINT;
typedef struct
{
int nIndex;
PHB_ITEM xValue;
} HB_TRACEPOINT;
typedef struct
{
char *szName;
char cType;
int nFrame;
int nIndex;
} HB_VARINFO;
typedef struct
{
char *szExpr;
PHB_ITEM pBlock;
int nVars;
char **aVars;
HB_VARINFO *aScopes;
} HB_WATCHPOINT;
typedef struct
{
char *szModule;
char *szFunction;
int nLine;
int nProcLevel;
int nLocals;
HB_VARINFO *aLocals;
int nStatics;
HB_VARINFO *aStatics;
} HB_CALLSTACKINFO;
typedef struct
{
char *szModule;
int nStatics;
HB_VARINFO *aStatics;
int nGlobals;
HB_VARINFO *aGlobals;
int nExternGlobals;
HB_VARINFO *aExternGlobals;
} HB_MODULEINFO;
typedef struct
{
BOOL bQuit;
BOOL bGo;
BOOL bInside;
int nBreakPoints;
HB_BREAKPOINT *aBreak;
int nTracePoints;
HB_TRACEPOINT *aTrace;
int nWatchPoints;
HB_WATCHPOINT *aWatch;
BOOL bTraceOver;
int nTraceLevel;
BOOL bNextRoutine;
BOOL bCodeBlock;
BOOL bToCursor;
int nToCursorLine;
char *szToCursorModule;
int nProcLevel;
int nCallStackLen;
HB_CALLSTACKINFO *aCallStack;
int nModules;
HB_MODULEINFO *aModules;
BOOL bCBTrace;
BOOL ( *pFunInvoke )( void );
BOOL bInitGlobals;
BOOL bInitStatics;
BOOL bInitLines;
PHB_ITEM pStopLines;
} HB_DEBUGINFO;
static HB_DEBUGINFO s_Info = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* bCBTrace */ TRUE, 0, 0, 0, 0, 0 };
static HB_DEBUGINFO *info = &s_Info;
static PHB_ITEM
hb_dbgActivateBreakArray( HB_DEBUGINFO *info );
static PHB_ITEM
hb_dbgActivateModuleArray( HB_DEBUGINFO *info );
static PHB_ITEM
hb_dbgActivateVarArray( int nVars, HB_VARINFO *aVars );
static void
hb_dbgAddLocal( HB_DEBUGINFO *info, char *szName, int nIndex, int nFrame );
static void
hb_dbgAddModule( HB_DEBUGINFO *info, char *szName );
static void
hb_dbgAddStack( HB_DEBUGINFO *info, char *szName, int nProcLevel );
static void
hb_dbgAddStatic( HB_DEBUGINFO *info, char *szName, int nIndex, int nFrame );
static void
hb_dbgAddStopLines( HB_DEBUGINFO *info, PHB_ITEM pItem );
static void
hb_dbgAddVar( int *nVars, HB_VARINFO **aVars, char *szName, char cType, int nIndex, int nFrame );
static void
hb_dbgEndProc( HB_DEBUGINFO *info );
static PHB_ITEM
hb_dbgEval( HB_DEBUGINFO *info, HB_WATCHPOINT *watch );
static PHB_ITEM
hb_dbgEvalMacro( char *szExpr, PHB_ITEM pItem );
static PHB_ITEM
hb_dbgEvalMakeBlock( HB_WATCHPOINT *watch );
static PHB_ITEM
hb_dbgEvalResolve( HB_DEBUGINFO *info, HB_WATCHPOINT *watch );
static BOOL
hb_dbgIsAltD( void );
static BOOL
hb_dbgIsBreakPoint( HB_DEBUGINFO *info, char *szModule, int nLine );
static BOOL
hb_dbgEqual( PHB_ITEM pItem1, PHB_ITEM pItem2 );
static void
hb_dbgQuit( HB_DEBUGINFO *info );
static PHB_ITEM
hb_dbgVarGet( HB_VARINFO *scope );
static void
hb_dbgVarSet( HB_VARINFO *scope, PHB_ITEM xNewValue );
static void
hb_dbgActivate( HB_DEBUGINFO *info )
{
PHB_DYNS pDynSym = hb_dynsymFind( "__DBGENTRY" );
if( pDynSym && pDynSym->pSymbol->value.pFunPtr )
{
int i;
PHB_ITEM aCallStack = hb_itemArrayNew( info->nCallStackLen );
PHB_ITEM aModules;
PHB_ITEM aBreak;
for ( i = 0; i < info->nCallStackLen; i++ )
{
HB_CALLSTACKINFO *pEntry = &info->aCallStack[ i ];
PHB_ITEM aEntry = hb_itemArrayNew( 6 );
PHB_ITEM pItem;
pItem = hb_itemPutC( NULL, pEntry->szModule );
hb_arraySet( aEntry, 1, pItem );
hb_itemRelease( pItem );
pItem = hb_itemPutC( NULL, pEntry->szFunction );
hb_arraySet( aEntry, 2, pItem );
hb_itemRelease( pItem );
pItem = hb_itemPutNL( NULL, pEntry->nLine );
hb_arraySet( aEntry, 3, pItem );
hb_itemRelease( pItem );
pItem = hb_itemPutNL( NULL, pEntry->nProcLevel );
hb_arraySet( aEntry, 4, pItem );
hb_itemRelease( pItem );
pItem = hb_dbgActivateVarArray( pEntry->nLocals, pEntry->aLocals );
hb_arraySet( aEntry, 5, pItem );
hb_itemRelease( pItem );
pItem = hb_dbgActivateVarArray( pEntry->nStatics, pEntry->aStatics );
hb_arraySet( aEntry, 6, pItem );
hb_itemRelease( pItem );
hb_arraySet( aCallStack, info->nCallStackLen - i, aEntry );
hb_itemRelease( aEntry );
}
aModules = hb_dbgActivateModuleArray( info );
aBreak = hb_dbgActivateBreakArray( info );
hb_vmPushDynSym( pDynSym );
hb_vmPushNil();
hb_vmPushLong( HB_DBG_ACTIVATE );
hb_vmPushPointer( info );
hb_vmPushLong( info->nProcLevel );
hb_vmPush( aCallStack );
hb_vmPush( aModules );
hb_vmPush( aBreak );
hb_itemRelease( aCallStack );
hb_itemRelease( aModules );
hb_itemRelease( aBreak );
hb_vmDo( 6 );
}
}
static PHB_ITEM
hb_dbgActivateBreakArray( HB_DEBUGINFO *info )
{
int i;
PHB_ITEM pArray = hb_itemArrayNew( info->nBreakPoints );
for ( i = 0; i < info->nBreakPoints; i++ )
{
PHB_ITEM pBreak = hb_itemArrayNew( 3 );
PHB_ITEM item;
if ( !info->aBreak[ i ].szFunction )
{
item = hb_itemPutNI( NULL, info->aBreak[ i ].nLine );
hb_arraySet( pBreak, 1, item );
hb_itemRelease( item );
item = hb_itemPutC( NULL, info->aBreak[ i ].szModule );
hb_arraySet( pBreak, 2, item );
hb_itemRelease( item );
}
else
{
item = hb_itemPutC( NULL, info->aBreak[ i ].szFunction );
hb_arraySet( pBreak, 3, item );
hb_itemRelease( item );
}
hb_arraySet( pArray, i + 1, pBreak );
hb_itemRelease( pBreak );
}
return pArray;
}
static PHB_ITEM
hb_dbgActivateModuleArray( HB_DEBUGINFO *info )
{
int i;
PHB_ITEM pArray = hb_itemArrayNew( info->nModules );
for ( i = 0; i < info->nModules; i++ )
{
PHB_ITEM pModule = hb_itemArrayNew( 4 );
PHB_ITEM item;
item = hb_itemPutC( NULL, info->aModules[ i ].szModule );
hb_arraySet( pModule, 1, item );
hb_itemRelease( item );
item = hb_dbgActivateVarArray( info->aModules[ i ].nStatics,
info->aModules[ i ].aStatics );
hb_arraySet( pModule, 2, item );
hb_itemRelease( item );
item = hb_dbgActivateVarArray( info->aModules[ i ].nGlobals,
info->aModules[ i ].aGlobals );
hb_arraySet( pModule, 3, item );
hb_itemRelease( item );
item = hb_dbgActivateVarArray( info->aModules[ i ].nExternGlobals,
info->aModules[ i ].aExternGlobals );
hb_arraySet( pModule, 4, item );
hb_itemRelease( item );
hb_arraySet( pArray, i + 1, pModule );
hb_itemRelease( pModule );
}
return pArray;
}
static PHB_ITEM
hb_dbgActivateVarArray( int nVars, HB_VARINFO *aVars )
{
int i;
PHB_ITEM pArray = hb_itemArrayNew( nVars );
for ( i = 0; i < nVars; i++ )
{
PHB_ITEM aVar = hb_itemArrayNew( 4 );
PHB_ITEM item;
item = hb_itemPutC( NULL, aVars[ i ].szName );
hb_arraySet( aVar, 1, item );
hb_itemRelease( item );
item = hb_itemPutNL( NULL, aVars[ i ].nIndex );
hb_arraySet( aVar, 2, item );
hb_itemRelease( item );
item = hb_itemPutCL( NULL, &aVars[ i ].cType, 1 );
hb_arraySet( aVar, 3, item );
hb_itemRelease( item );
item = hb_itemPutNL( NULL, aVars[ i ].nFrame );
hb_arraySet( aVar, 4, item );
hb_itemRelease( item );
hb_arraySet( pArray, i + 1, aVar );
hb_itemRelease( aVar );
}
return pArray;
}
HB_EXPORT void
hb_dbgEntry( int nMode, int nLine, char *szName, int nIndex, int nFrame )
{
int i;
ULONG nProcLevel;
char szProcName[ HB_SYMBOL_NAME_LEN + HB_SYMBOL_NAME_LEN + 5 ];
if ( ( info->bInside || info->bQuit ) && nMode != HB_DBG_VMQUIT )
return;
switch ( nMode )
{
case HB_DBG_MODULENAME:
HB_TRACE( HB_TR_DEBUG, ( "MODULENAME %s", szName ) );
if ( szName[ strlen( szName ) - 1 ] == ':' )
return;
hb_procinfo( 0, szProcName, NULL, NULL );
if ( !strncmp( szProcName, "(_INITSTATICS", 13 ) )
info->bInitStatics = TRUE;
else if ( !strncmp( szProcName, "(_INITGLOBALS", 13 ) )
info->bInitGlobals = TRUE;
else if ( !strncmp( szProcName, "(_INITLINES", 11 ) )
info->bInitLines = TRUE;
if ( info->bInitStatics || info->bInitGlobals )
hb_dbgAddModule( info, szName );
else if ( !strncmp( szProcName, "(b)", 3 ) )
info->bCodeBlock = TRUE;
else if ( info->bNextRoutine )
info->bNextRoutine = FALSE;
hb_dbgAddStack( info, szName, hb_dbg_ProcLevel() );
for ( i = 0; i < info->nBreakPoints; i++ )
{
if ( info->aBreak[ i ].szFunction
&& !strcmp( info->aBreak[ i ].szFunction, szProcName ) )
{
hb_dbg_InvokeDebug( TRUE );
break;
}
}
return;
case HB_DBG_LOCALNAME:
HB_TRACE( HB_TR_DEBUG, ( "LOCALNAME %s index %d", szName, nIndex ) );
hb_dbgAddLocal( info, szName, nIndex, hb_dbg_ProcLevel() );
return;
case HB_DBG_STATICNAME:
HB_TRACE( HB_TR_DEBUG, ( "STATICNAME %s index %d frame %d", szName, nIndex, nFrame ) );
hb_dbgAddStatic( info, szName, nIndex, nFrame );
return;
case HB_DBG_SHOWLINE:
{
HB_CALLSTACKINFO *pTop = &info->aCallStack[ info->nCallStackLen - 1 ];
BOOL bOldClsScope;
HB_TRACE( HB_TR_DEBUG, ( "SHOWLINE %d", nLine ) );
nProcLevel = hb_dbg_ProcLevel();
/* Check if we've hit a tracepoint */
bOldClsScope = hb_clsSetScope( FALSE );
for ( i = 0; i < info->nTracePoints; i++ )
{
HB_TRACEPOINT *tp = &info->aTrace[ i ];
PHB_ITEM xValue;
xValue = hb_dbgEval( info, &info->aWatch[ tp->nIndex ] );
if ( !xValue )
xValue = hb_itemNew( NULL );
if ( xValue->type != tp->xValue->type || !hb_dbgEqual( xValue, tp->xValue ) )
{
hb_itemCopy( tp->xValue, xValue );
hb_itemRelease( xValue );
pTop->nLine = nLine;
info->nProcLevel = nProcLevel - ( hb_dbgIsAltD() ? 2 : 0 );
info->bTraceOver = FALSE;
info->bCodeBlock = FALSE;
info->bGo = FALSE;
if ( info->bToCursor )
{
info->bToCursor = FALSE;
FREE( info->szToCursorModule );
}
info->bNextRoutine = FALSE;
hb_dbgActivate( info );
return;
}
hb_itemRelease( xValue );
}
hb_clsSetScope( bOldClsScope );
if ( hb_dbgIsBreakPoint( info, pTop->szModule, nLine )
|| hb_dbg_InvokeDebug( FALSE )
|| ( info->pFunInvoke && info->pFunInvoke() ) )
{
info->bTraceOver = FALSE;
if ( info->bToCursor )
{
info->bToCursor = FALSE;
FREE( info->szToCursorModule );
}
info->bNextRoutine = FALSE;
info->bGo = FALSE;
}
/* Check if we must skip every level above info->nTraceLevel */
if ( info->bTraceOver )
{
if ( info->nTraceLevel < info->nCallStackLen )
return;
info->bTraceOver = FALSE;
}
/* Check if we're skipping to a specific line of source */
if ( info->bToCursor )
{
if ( nLine == info->nToCursorLine
&& FILENAME_EQUAL( pTop->szModule, info->szToCursorModule ) )
{
FREE( info->szToCursorModule );
info->bToCursor = FALSE;
}
else
{
return;
}
}
/* Check if'we skipping to the end of current routine */
if ( info->bNextRoutine )
return;
if ( info->bCodeBlock )
{
info->bCodeBlock = FALSE;
if ( !info->bCBTrace )
return;
}
pTop->nLine = nLine;
if ( !info->bGo )
{
info->nProcLevel = nProcLevel - ( hb_dbgIsAltD() ? 2 : 0 );
hb_dbgActivate( info );
}
return;
}
case HB_DBG_ENDPROC:
if ( info->bQuit )
return;
HB_TRACE( HB_TR_DEBUG, ( "ENDPROC", nLine ) );
if ( info->bInitLines )
{
hb_dbgAddStopLines( info, hb_stackReturnItem() );
}
info->bCodeBlock = FALSE;
info->bInitStatics = FALSE;
info->bInitGlobals = FALSE;
info->bInitLines = FALSE;
hb_dbgEndProc( info );
return;
case HB_DBG_VMQUIT:
hb_dbgQuit( info );
return;
}
}
HB_EXPORT void
hb_dbgAddBreak( void *handle, char *cModule, int nLine, char *szFunction )
{
HB_DEBUGINFO *info = (HB_DEBUGINFO *)handle;
HB_BREAKPOINT *pBreak;
pBreak = ARRAY_ADD( HB_BREAKPOINT, info->aBreak, info->nBreakPoints );
pBreak->szModule = STRDUP( cModule );
pBreak->nLine = nLine;
if ( szFunction )
{
pBreak->szFunction = STRDUP( szFunction );
}
else
{
pBreak->szFunction = NULL;
}
}
static void
hb_dbgAddLocal( HB_DEBUGINFO *info, char *szName, int nIndex, int nFrame )
{
if ( info->bInitGlobals )
{
HB_MODULEINFO *module = &info->aModules[ info->nModules - 1 ];
hb_dbgAddVar( &module->nGlobals, &module->aGlobals, szName, 'G', nIndex, hb_dbg_vmVarGCount() );
}
else
{
HB_CALLSTACKINFO *top = &info->aCallStack[ info->nCallStackLen - 1 ];
hb_dbgAddVar( &top->nLocals, &top->aLocals, szName, 'L', nIndex, nFrame );
}
}
static void
hb_dbgAddModule( HB_DEBUGINFO *info, char *szName )
{
char *ptr;
if ( NULL != ( ptr = strrchr( szName, '/' ) ) )
{
szName = ptr + 1;
}
if ( NULL != ( ptr = strrchr( szName, '\\' ) ) )
{
szName = ptr + 1;
}
if ( !info->nModules || strcmp( info->aModules[ info->nModules - 1 ].szModule, szName ) )
{
HB_MODULEINFO *pModule;
pModule = ARRAY_ADD( HB_MODULEINFO, info->aModules, info->nModules );
pModule->szModule = szName;
pModule->nStatics = 0;
pModule->nGlobals = 0;
pModule->nExternGlobals = 0;
}
}
static void
hb_dbgAddStack( HB_DEBUGINFO *info, char *szName, int nProcLevel )
{
char szBuff[ HB_SYMBOL_NAME_LEN + HB_SYMBOL_NAME_LEN + 5 ];
HB_CALLSTACKINFO *top;
char *szFunction = strrchr( szName, ':' );
char *tmp;
if ( szFunction )
{
szFunction++;
}
top = ARRAY_ADD( HB_CALLSTACKINFO, info->aCallStack, info->nCallStackLen );
if ( info->bCodeBlock )
{
memcpy( szBuff, "(b)", 3 );
hb_strncpy( szBuff + 3, szFunction, sizeof( szBuff ) - 4 );
top->szFunction = STRDUP( szBuff );
}
else
{
if ( szFunction )
{
top->szFunction = STRDUP( szFunction );
}
else
{
/* We're in an (_INITSTATICSnnnnn) pseudo-function */
hb_procinfo( 0, szBuff, NULL, NULL );
top->szFunction = STRDUP( szBuff );
}
}
tmp = strrchr( szName, '/' );
if ( tmp )
szName = tmp + 1;
tmp = strrchr( szName, '\\' );
if ( tmp )
szName = tmp + 1;
if ( szFunction )
{
STRNDUP( top->szModule, szName, szFunction - szName - 1 );
}
else
{
top->szModule = STRDUP( szName );
}
top->nProcLevel = nProcLevel;
top->nLine = 0;
top->nLocals = 0;
top->nStatics = 0;
}
static void
hb_dbgAddStatic( HB_DEBUGINFO *info, char *szName, int nIndex, int nFrame )
{
if ( info->bInitGlobals )
{
HB_MODULEINFO *module = &info->aModules[ info->nModules - 1 ];
hb_dbgAddVar( &module->nExternGlobals, &module->aExternGlobals, szName,
'G', nIndex, hb_dbg_vmVarGCount() );
}
else if ( info->bInitStatics )
{
HB_MODULEINFO *module = &info->aModules[ info->nModules - 1 ];
hb_dbgAddVar( &module->nStatics, &module->aStatics, szName, 'S', nIndex, nFrame );
}
else
{
HB_CALLSTACKINFO *top = &info->aCallStack[ info->nCallStackLen - 1 ];
hb_dbgAddVar( &top->nStatics, &top->aStatics, szName, 'S', nIndex, nFrame );
}
}
static void
hb_dbgAddStopLines( HB_DEBUGINFO *info, PHB_ITEM pItem )
{
int i, nLinesLen;
if ( !info->pStopLines )
{
info->pStopLines = hb_itemNew( pItem );
}
else
{
int j;
int nItemLen = hb_itemSize( pItem );
nLinesLen = hb_itemSize( info->pStopLines );
for ( i = 1; i <= nItemLen; i++ )
{
PHB_ITEM pEntry = hb_arrayGetItemPtr( pItem, i );
char *szModule = hb_arrayGetCPtr( pEntry, 1 );
char *p;
BOOL bFound = FALSE;
if ( ( p = strrchr( szModule, '/' ) ) != NULL
|| ( p = strrchr( szModule, '\\' ) ) != NULL )
{
szModule = p + 1;
}
for ( j = 1; j <= nLinesLen; j++ )
{
PHB_ITEM pLines = hb_arrayGetItemPtr( info->pStopLines, j );
if ( !strcmp( hb_arrayGetCPtr( pLines, 1 ), szModule ) )
{
/* Merge stopline info */
int nOrigMin = hb_arrayGetNL( pLines, 2 );
int nNewMin = hb_arrayGetNL( pEntry, 2 );
int nOrigLen = hb_arrayGetCLen( pLines, 3 );
int nNewLen = hb_arrayGetCLen( pEntry, 3 );
int nMin = HB_MIN( nNewMin, nOrigMin );
int nMax = HB_MAX( nNewMin + nNewLen * 8, nOrigMin + nOrigLen * 8 );
char *pOrigBuffer = hb_arrayGetCPtr( pLines, 3 );
char *pNewBuffer = hb_arrayGetCPtr( pEntry, 3 );
int nLen = ( nMax + 1 - nMin + 7 ) / 8 + 1;
int k;
char *pBuffer = (char *) hb_xgrab( nLen );
hb_xmemset( pBuffer, 0, nLen );
memmove( &( pBuffer[ ( nNewMin - nMin ) / 8 ] ), pNewBuffer, nNewLen );
for ( k = 0; k < nOrigLen; k++ )
{
pBuffer[ nOrigMin / 8 + k - nMin / 8 ] |= pOrigBuffer[ k ];
}
hb_itemPutNL( hb_arrayGetItemPtr( pLines, 2 ), nMin );
hb_itemPutCPtr( hb_arrayGetItemPtr( pLines, 3 ), pBuffer, nLen - 1 );
bFound = TRUE;
break;
}
}
if ( !bFound )
{
hb_arrayAddForward( info->pStopLines, pEntry );
}
}
}
nLinesLen = hb_itemSize( info->pStopLines );
for ( i = 1; i <= nLinesLen; i++ )
{
PHB_ITEM pEntry = hb_arrayGetItemPtr( info->pStopLines, i );
char *szModule = hb_arrayGetCPtr( pEntry, 1 );
char *p;
if ( ( p = strrchr( szModule, '/' ) ) != NULL
|| ( p = strrchr( szModule, '\\' ) ) != NULL )
{
char *szName = hb_strdup( p + 1 );
hb_itemPutC( hb_arrayGetItemPtr( pEntry, 1 ), szName );
hb_xfree( szName );
}
}
}
static void
hb_dbgAddVar( int *nVars, HB_VARINFO **aVars, char *szName, char cType, int nIndex, int nFrame )
{
HB_VARINFO *var;
var = ARRAY_ADD( HB_VARINFO, *aVars, *nVars );
var->szName = szName;
var->cType = cType;
var->nIndex = nIndex;
var->nFrame = nFrame;
}
HB_EXPORT void
hb_dbgAddWatch( void *handle, char *szExpr, BOOL bTrace )
{
HB_DEBUGINFO *info = (HB_DEBUGINFO *)handle;
HB_WATCHPOINT *pWatch;
pWatch = ARRAY_ADD( HB_WATCHPOINT, info->aWatch, info->nWatchPoints );
pWatch->szExpr = STRDUP( szExpr );
pWatch->pBlock = NULL;
pWatch->nVars = 0;
if ( bTrace )
{
HB_TRACEPOINT *pTrace = ARRAY_ADD( HB_TRACEPOINT, info->aTrace, info->nTracePoints );
pTrace->nIndex = info->nWatchPoints - 1;
pTrace->xValue = hb_dbgEval( info, pWatch );
}
}
static void
hb_dbgClearWatch( HB_WATCHPOINT *pWatch )
{
FREE( pWatch->szExpr );
if ( pWatch->pBlock )
{
hb_itemRelease( pWatch->pBlock );
}
if ( pWatch->nVars )
{
int i;
for (i = 0; i < pWatch->nVars; i++)
{
FREE( pWatch->aVars[ i ] );
}
FREE( pWatch->aVars );
}
}
HB_EXPORT void
hb_dbgDelBreak( void *handle, int nBreak )
{
HB_DEBUGINFO *info = (HB_DEBUGINFO *)handle;
HB_BREAKPOINT *pBreak = &info->aBreak[ nBreak ];
FREE( pBreak->szModule );
if ( pBreak->szFunction )
{
FREE( pBreak->szFunction );
}
ARRAY_DEL( HB_BREAKPOINT, info->aBreak, info->nBreakPoints, nBreak );
}
HB_EXPORT void
hb_dbgDelWatch( void *handle, int nWatch )
{
HB_DEBUGINFO *info = (HB_DEBUGINFO *)handle;
HB_WATCHPOINT *pWatch = &info->aWatch[ nWatch ];
int i;
hb_dbgClearWatch( pWatch );
ARRAY_DEL( HB_WATCHPOINT, info->aWatch, info->nWatchPoints, nWatch );
for ( i = 0; i < info->nTracePoints; i++ )
{
HB_TRACEPOINT *pTrace = &info->aTrace[ i ];
if ( pTrace->nIndex == nWatch )
{
if ( pTrace->xValue )
{
hb_itemRelease( pTrace->xValue );
}
ARRAY_DEL( HB_TRACEPOINT, info->aTrace, info->nTracePoints, i );
i--;
}
else if ( pTrace->nIndex > nWatch )
{
pTrace->nIndex--;
}
}
}
static void
hb_dbgEndProc( HB_DEBUGINFO *info )
{
HB_CALLSTACKINFO *top;
if ( !info->nCallStackLen )
return;
top = &info->aCallStack[ --info->nCallStackLen ];
FREE( top->szFunction );
FREE( top->szModule );
if ( top->nLocals )
{
FREE( top->aLocals );
}
if ( top->nStatics )
{
FREE( top->aStatics );
}
if ( !info->nCallStackLen )
{
FREE( info->aCallStack );
info->aCallStack = NULL;
}
}
static BOOL
hb_dbgEqual( PHB_ITEM pItem1, PHB_ITEM pItem2 )
{
if ( pItem1->type != pItem2->type )
return FALSE;
if ( HB_IS_NIL( pItem1 ) )
return HB_IS_NIL( pItem2 );
if ( HB_IS_LOGICAL( pItem1 ) )
return ( pItem1->item.asLogical.value == pItem2->item.asLogical.value );
if ( HB_IS_POINTER( pItem1 ) )
return ( pItem1->item.asPointer.value == pItem2->item.asPointer.value );
if ( HB_IS_STRING( pItem1 ) )
return !hb_itemStrCmp( pItem1, pItem2, TRUE );
if ( HB_IS_NUMINT( pItem1 ) )
return ( HB_ITEM_GET_NUMINTRAW( pItem1 ) == HB_ITEM_GET_NUMINTRAW( pItem2 ) );
if ( HB_IS_NUMERIC( pItem1 ) )
return ( hb_itemGetND( pItem1 ) == hb_itemGetND( pItem2 ) );
if ( HB_IS_ARRAY( pItem1 ) )
return ( pItem1->item.asArray.value == pItem2->item.asArray.value );
if ( HB_IS_HASH( pItem1 ) )
return ( pItem1->item.asHash.value == pItem2->item.asHash.value );
return FALSE;
}
static PHB_ITEM
hb_dbgEval( HB_DEBUGINFO *info, HB_WATCHPOINT *watch )
{
PHB_ITEM xResult = NULL;
HB_TRACE( HB_TR_DEBUG, ( "expr %s", watch->szExpr ) );
/* Check if we have a cached pBlock */
if ( !watch->pBlock )
{
watch->pBlock = hb_dbgEvalMakeBlock( watch );
}
if ( watch->pBlock )
{
PHB_ITEM aVars = hb_dbgEvalResolve( info, watch );
PHB_ITEM aNewVars = hb_itemArrayNew( watch->nVars );
int i;
hb_arrayCopy( aVars, aNewVars, NULL, NULL, NULL );
info->bInside = TRUE;
xResult = hb_itemDo( watch->pBlock, 1, aNewVars );
info->bInside = FALSE;
for ( i = 0; i < watch->nVars; i++ )
{
PHB_ITEM xOldValue = hb_itemArrayGet( aVars, i + 1 );
PHB_ITEM xNewValue = hb_itemArrayGet( aNewVars, i + 1 );
if ( !hb_dbgEqual( xOldValue, xNewValue ) )
{
hb_dbgVarSet( &watch->aScopes[ i ], xNewValue );
}
hb_itemRelease( xOldValue );
hb_itemRelease( xNewValue );
}
hb_itemRelease( aVars );
hb_itemRelease( aNewVars );
for ( i = 0; i < watch->nVars; i++ )
{
if ( watch->aScopes[ i ].cType == 'M' )
{
FREE( watch->aScopes[ i ].szName );
}
}
if ( watch->nVars )
{
FREE( watch->aScopes );
}
}
return xResult;
}
static PHB_ITEM
hb_dbgEvalMacro( char *szExpr, PHB_ITEM pItem )
{
PHB_ITEM pStr;
const char *type;
pStr = hb_itemPutC( NULL, szExpr );
type = hb_macroGetType( pStr );
hb_itemRelease( pStr );
if ( ( !strcmp( type, "U" ) || !strcmp( type, "UE" ) ) )
{
return NULL;
}
hb_vmPushString( szExpr, strlen( szExpr ) );
hb_macroGetValue( hb_stackItemFromTop( -1 ), 0, HB_SM_RT_MACRO );
hb_itemForwardValue( pItem, hb_stackItemFromTop( -1 ) );
hb_stackPop();
return pItem;
}
#define IS_IDENT_START( c ) ( isalpha( (UCHAR) (c) ) || (c) == '_' )
#define IS_IDENT_CHAR( c ) ( IS_IDENT_START( (c) ) || isdigit( (UCHAR) (c) ) )
static PHB_ITEM
hb_dbgEvalMakeBlock( HB_WATCHPOINT *watch )
{
int i = 0;
PHB_ITEM pBlock;
BOOL bAfterId = FALSE;
char *s;
watch->nVars = 0;
while ( watch->szExpr[ i ] )
{
char c = watch->szExpr[ i ];
if ( IS_IDENT_START( c ) )
{
int nStart = i, nLen;
int j = i;
char *szWord;
while ( c && IS_IDENT_CHAR( c ) )
{
j++;
c = watch->szExpr[ j ];
}
nLen = j - i;
STRNDUP( szWord, watch->szExpr + i, nLen );
i = j;
if ( c )
{
while ( watch->szExpr[ i ] && watch->szExpr[ i ] == ' ' )
{
i++;
}
if ( watch->szExpr[ i ] == '(' )
{
FREE( szWord );
continue;
}
if ( watch->szExpr[ i ] == '-' && watch->szExpr[ i + 1 ] == '>' )
{
i += 2;
while ( ( c = watch->szExpr[ i ] ) != '\0' && IS_IDENT_CHAR( c ) )
{
i++;
}
FREE( szWord );
continue;
}
}
hb_strupr( szWord );
for ( j = 0; j < watch->nVars; j++ )
{
if ( !strcmp( szWord, watch->aVars[ j ] ) )
{
break;
}
}
if ( j == watch->nVars )
{
*ARRAY_ADD( char *, watch->aVars, watch->nVars ) = szWord;
}
else
{
FREE( szWord );
}
{
char *t = (char *) ALLOC( strlen( watch->szExpr ) - nLen + 9 + 1 );
memmove( t, watch->szExpr, nStart );
memmove( t + nStart, "__dbg[", 6 );
t[ nStart + 6 ] = '0' + ( ( j + 1 ) / 10 );
t[ nStart + 7 ] = '0' + ( ( j + 1 ) % 10 );
t[ nStart + 8 ] = ']';
strcpy( t + nStart + 9, watch->szExpr + nStart + nLen );
FREE( watch->szExpr );
watch->szExpr = t;
i = nStart + 9;
}
bAfterId = TRUE;
continue;
}
if ( c == '.' )
{
if ( watch->szExpr[ i + 1 ]
&& strchr( "TtFf", watch->szExpr[ i + 1 ] )
&& watch->szExpr[ i + 2 ] == '.' )
{
i += 3;
}
else if ( !hb_strnicmp( watch->szExpr + i + 1, "OR.", 3 ) )
{
i += 4;
}
else if ( !hb_strnicmp( watch->szExpr + i + 1, "AND.", 4 )
|| !hb_strnicmp( watch->szExpr + i + 1, "NOT.", 4 ) )
{
i += 5;
}
else
{
i++;
}
bAfterId = FALSE;
continue;
}
if ( c == ':'
|| ( c == '-' && watch->szExpr[ i + 1 ] == '>'
&& IS_IDENT_START( watch->szExpr[ i + 2 ] ) ) )
{
if ( c == '-' )
{
i++;
}
i++;
while ( watch->szExpr[ i ] && IS_IDENT_CHAR( watch->szExpr[ i ] ) )
{
i++;
}
bAfterId = TRUE;
continue;
}
if ( strchr( " !#$=<>(+-*/%^|,{&", c ) )
{
i++;
bAfterId = FALSE;
continue;
}
if ( c == '\'' || c == '\"' )
{
i++;
while ( watch->szExpr[ i ] && watch->szExpr[ i ] != c )
{
i++;
}
if ( watch->szExpr[ i ] )
{
i++;
}
bAfterId = TRUE;
continue;
}
if ( c == '[' )
{
i++;
if ( bAfterId )
{
bAfterId = FALSE;
}
else
{
while ( watch->szExpr[ i ] && watch->szExpr[ i ] != ']' )
{
i++;
}
if ( watch->szExpr[ i ] )
{
i++;
}
bAfterId = TRUE;
}
continue;
}
i++;
}
s = ( char * ) ALLOC( 8 + strlen( watch->szExpr ) + 1 + 1 );
strcpy( s, "{|__dbg|" );
strcat( s, watch->szExpr );
strcat( s, "}" );
pBlock = hb_itemNew( NULL );
if( ! hb_dbgEvalMacro( s, pBlock ) )
{
hb_itemRelease( pBlock );
pBlock = NULL;
}
FREE( s );
return pBlock;
}
static PHB_ITEM
hb_dbgEvalResolve( HB_DEBUGINFO *info, HB_WATCHPOINT *watch )
{
int i;
HB_CALLSTACKINFO *top = &info->aCallStack[ info->nCallStackLen - 1 ];
PHB_ITEM aVars = hb_itemArrayNew( watch->nVars );
HB_VARINFO *scopes;
HB_MODULEINFO *module = NULL;
int nProcLevel;
if ( !watch->nVars )
{
return aVars;
}
scopes = (HB_VARINFO *) ALLOC( watch->nVars * sizeof( HB_VARINFO ) );
nProcLevel = hb_dbg_ProcLevel();
for ( i = 0; i < info->nModules; i++ )
{
if ( !strcmp( info->aModules[ i ].szModule, top->szModule ) )
{
module = &info->aModules[ i ];
break;
}
}
for ( i = 0; i < watch->nVars; i++ )
{
char *name = watch->aVars[ i ];
HB_VARINFO *var;
int j;
PHB_ITEM pItem;
for ( j = 0; j < top->nLocals; j++ )
{
var = &top->aLocals[ j ];
if ( !strcmp( name, var->szName ) )
{
scopes[ i ].cType = 'L';
scopes[ i ].nFrame = nProcLevel - var->nFrame;
scopes[ i ].nIndex = var->nIndex;
hb_itemArrayPut( aVars, i + 1, hb_dbgVarGet( &scopes[ i ] ) );
break;
}
}
if ( j < top->nLocals )
continue;
for ( j = 0; j < top->nStatics; j++ )
{
var = &top->aStatics[ j ];
if ( !strcmp( name, var->szName ) )
{
scopes[ i ].cType = 'S';
scopes[ i ].nFrame = var->nFrame;
scopes[ i ].nIndex = var->nIndex;
hb_itemArrayPut( aVars, i + 1, hb_dbgVarGet( &scopes[ i ] ) );
break;
}
}
if ( j < top->nStatics )
continue;
if ( module )
{
for ( j = 0; j < module->nStatics; j++ )
{
var = &module->aStatics[ j ];
if ( !strcmp( name, var->szName ) )
{
scopes[ i ].cType = 'S';
scopes[ i ].nFrame = var->nFrame;
scopes[ i ].nIndex = var->nIndex;
hb_itemArrayPut( aVars, i + 1, hb_dbgVarGet( &scopes[ i ] ) );
break;
}
}
if ( j < module->nStatics )
continue;
for ( j = 0; j < module->nGlobals; j++ )
{
var = &module->aGlobals[ j ];
if ( !strcmp( name, var->szName ) )
{
scopes[ i ].cType = 'G';
scopes[ i ].nFrame = var->nFrame;
scopes[ i ].nIndex = var->nIndex;
hb_itemArrayPut( aVars, i + 1, hb_dbgVarGet( &scopes[ i ] ) );
break;
}
}
if ( j < module->nGlobals )
continue;
for ( j = 0; j < module->nExternGlobals; j++ )
{
var = &module->aExternGlobals[ j ];
if ( !strcmp( name, var->szName ) )
{
scopes[ i ].cType = 'G';
scopes[ i ].nFrame = var->nFrame;
scopes[ i ].nIndex = var->nIndex;
hb_itemArrayPut( aVars, i + 1, hb_dbgVarGet( &scopes[ i ] ) );
break;
}
}
if ( j < module->nExternGlobals )
continue;
}
scopes[ i ].cType = 'M';
scopes[ i ].szName = STRDUP( name );
pItem = hb_dbgVarGet( &scopes[ i ] );
if ( pItem )
{
hb_itemArrayPut( aVars, i + 1, pItem );
}
if ( scopes[ i ].cType == 'F' )
{
hb_itemRelease( pItem );
}
}
watch->aScopes = scopes;
return aVars;
}
HB_EXPORT PHB_ITEM
hb_dbgGetExpressionValue( void *handle, char *expression )
{
HB_DEBUGINFO *info = (HB_DEBUGINFO *)handle;
PHB_ITEM result;
HB_WATCHPOINT point;
point.szExpr = STRDUP( expression );
point.pBlock = NULL;
point.nVars = 0;
result = hb_dbgEval( info, &point );
hb_dbgClearWatch( &point );
return result;
}
HB_EXPORT PHB_ITEM
hb_dbgGetSourceFiles( void *handle )
{
HB_DEBUGINFO *info = (HB_DEBUGINFO *)handle;
int nModules = hb_itemSize( info->pStopLines );
PHB_ITEM ret = hb_itemArrayNew( nModules );
int i;
for ( i = 1; i <= nModules; i++ )
{
hb_arraySet( ret, i, hb_arrayGetItemPtr( hb_arrayGetItemPtr( info->pStopLines, i ), 1 ) );
}
return ret;
}
HB_EXPORT PHB_ITEM
hb_dbgGetWatchValue( void *handle, int nWatch )
{
HB_DEBUGINFO *info = (HB_DEBUGINFO *)handle;
return hb_dbgEval( info, &( info->aWatch[ nWatch ] ) );
}
static BOOL
hb_dbgIsAltD( void )
{
char szName[ HB_SYMBOL_NAME_LEN + HB_SYMBOL_NAME_LEN + 5];
hb_procinfo( 1, szName, NULL, NULL );
return !strcmp( szName, "ALTD" );
}
static BOOL
hb_dbgIsBreakPoint( HB_DEBUGINFO *info, char *szModule, int nLine )
{
int i;
for ( i = 0; i < info->nBreakPoints; i++ )
{
HB_BREAKPOINT *point = &info->aBreak[ i ];
if ( point->nLine == nLine
&& FILENAME_EQUAL( szModule, point->szModule ) )
return TRUE;
}
return FALSE;
}
HB_EXPORT BOOL
hb_dbgIsValidStopLine( void *handle, char *szModule, int nLine )
{
HB_DEBUGINFO *info = (HB_DEBUGINFO *)handle;
int nModules = hb_itemSize( info->pStopLines );
int i;
for ( i = 1; i <= nModules; i++ )
{
PHB_ITEM pEntry = hb_arrayGetItemPtr( info->pStopLines, i );
if ( FILENAME_EQUAL( hb_arrayGetCPtr( pEntry, 1 ), szModule ) )
{
int nMin = hb_arrayGetNL( pEntry, 2 );
int nOfs = nLine - nMin;
if ( nLine < nMin || (ULONG)( nOfs / 8 ) > hb_arrayGetCLen( pEntry, 3 ) )
{
return FALSE;
}
return ( hb_arrayGetCPtr( pEntry, 3 )[ nOfs / 8 ] & ( 1 << ( nOfs % 8 ) ) ) != 0;
}
}
return FALSE;
}
static void
hb_dbgQuit( HB_DEBUGINFO *info )
{
while ( info->nWatchPoints )
{
hb_dbgDelWatch( info, info->nWatchPoints - 1 );
}
while ( info->nBreakPoints )
{
hb_dbgDelBreak( info, info->nBreakPoints - 1 );
}
while ( info->nCallStackLen )
{
hb_dbgEndProc( info );
}
if ( info->pStopLines )
{
hb_itemRelease( info->pStopLines );
}
while ( info->nModules )
{
int nModules = info->nModules - 1;
HB_MODULEINFO *module = &info->aModules[ nModules ];
if ( module->nStatics )
{
FREE( module->aStatics );
}
ARRAY_DEL( HB_MODULEINFO, info->aModules, info->nModules, nModules );
}
if ( info->bToCursor )
{
info->bToCursor = FALSE;
FREE( info->szToCursorModule );
}
}
HB_EXPORT void
hb_dbgSetCBTrace( void *handle, BOOL bCBTrace )
{
HB_DEBUGINFO *info = (HB_DEBUGINFO *)handle;
info->bCBTrace = bCBTrace;
}
HB_EXPORT void
hb_dbgSetGo( void *handle )
{
HB_DEBUGINFO *info = (HB_DEBUGINFO *)handle;
info->bGo = TRUE;
}
HB_EXPORT void
hb_dbgSetInvoke( void *handle, BOOL ( *pFunInvoke )( void ) )
{
HB_DEBUGINFO *info = (HB_DEBUGINFO *)handle;
info->pFunInvoke = pFunInvoke;
}
HB_EXPORT void
hb_dbgSetNextRoutine( void *handle )
{
HB_DEBUGINFO *info = (HB_DEBUGINFO *)handle;
info->bNextRoutine = TRUE;
}
HB_EXPORT void
hb_dbgSetQuit( void *handle )
{
HB_DEBUGINFO *info = (HB_DEBUGINFO *)handle;
info->bQuit = TRUE;
}
HB_EXPORT void
hb_dbgSetToCursor( void *handle, char *szModule, int nLine )
{
HB_DEBUGINFO *info = (HB_DEBUGINFO *)handle;
info->bToCursor = TRUE;
info->szToCursorModule = STRDUP( szModule );
info->nToCursorLine = nLine;
}
HB_EXPORT void
hb_dbgSetTrace( void *handle )
{
HB_DEBUGINFO *info = (HB_DEBUGINFO *)handle;
info->bTraceOver = TRUE;
info->nTraceLevel = info->nCallStackLen;
}
HB_EXPORT void
hb_dbgSetWatch( void *handle, int nWatch, char *szExpr, BOOL bTrace )
{
HB_DEBUGINFO *info = (HB_DEBUGINFO *)handle;
HB_WATCHPOINT *pWatch = &info->aWatch[ nWatch ];
int i;
hb_dbgClearWatch( pWatch );
pWatch->szExpr = STRDUP( szExpr );
pWatch->pBlock = NULL;
for ( i = 0; i < info->nTracePoints; i++ )
{
HB_TRACEPOINT *pTrace = &info->aTrace[ i ];
if ( pTrace->nIndex == nWatch )
{
if ( pTrace->xValue )
{
hb_itemRelease( pTrace->xValue );
}
ARRAY_DEL( HB_TRACEPOINT, info->aTrace, info->nTracePoints, i );
break;
}
}
if ( bTrace )
{
HB_TRACEPOINT *pTrace = ARRAY_ADD( HB_TRACEPOINT, info->aTrace, info->nTracePoints );
pTrace->nIndex = nWatch;
pTrace->xValue = hb_dbgEval( info, pWatch );
}
}
static PHB_ITEM
hb_dbgVarGet( HB_VARINFO *scope )
{
switch ( scope->cType )
{
case 'G':
return hb_dbg_vmVarGGet( scope->nFrame, scope->nIndex );
case 'L':
return hb_dbg_vmVarLGet( scope->nFrame, scope->nIndex );
case 'S':
return hb_dbg_vmVarSGet( scope->nFrame, scope->nIndex );
case 'M':
{
PHB_DYNS pDyn;
pDyn = hb_dynsymFind( scope->szName );
if ( pDyn != NULL )
{
if ( pDyn->hMemvar == 0 )
{
PHB_ITEM pItem = hb_itemNew( NULL );
if ( hb_rddFieldGet( pItem, pDyn->pSymbol ) == SUCCESS )
{
scope->cType = 'F';
return pItem;
}
hb_itemRelease( pItem );
}
else
{
return hb_memvarGetValueByHandle( pDyn->hMemvar );
}
}
return NULL;
}
default:
return NULL;
}
}
static void
hb_dbgVarSet( HB_VARINFO *scope, PHB_ITEM xNewValue )
{
switch ( scope->cType )
{
case 'G':
case 'L':
case 'S':
hb_itemCopy( hb_dbgVarGet( scope ), xNewValue );
break;
case 'M':
{
PHB_DYNS pDynSym = hb_dynsymFind( "__MVPUT" );
if ( pDynSym && pDynSym->pSymbol->value.pFunPtr )
{
hb_vmPushDynSym( pDynSym );
hb_vmPushNil();
hb_vmPushString( scope->szName, strlen( scope->szName ) );
hb_vmPush( xNewValue );
hb_vmDo( 2 );
}
break;
}
}
}
/*
* .prg functions
*/
HB_FUNC( HB_DBG_SETENTRY )
{
hb_dbg_SetEntry( hb_dbgEntry );
}
HB_FUNC( HB_DBG_SETGO )
{
void * ptr = hb_parptr( 1 );
if( ptr )
hb_dbgSetGo( ptr );
}
HB_FUNC( HB_DBG_SETTRACE )
{
void * ptr = hb_parptr( 1 );
if( ptr )
hb_dbgSetTrace( ptr );
}
HB_FUNC( HB_DBG_SETCBTRACE )
{
void * ptr = hb_parptr( 1 );
if( ptr )
hb_dbgSetCBTrace( ptr, hb_parl( 2 ) );
}
HB_FUNC( HB_DBG_SETNEXTROUTINE )
{
void * ptr = hb_parptr( 1 );
if( ptr )
hb_dbgSetNextRoutine( ptr );
}
HB_FUNC( HB_DBG_SETQUIT )
{
void * ptr = hb_parptr( 1 );
if( ptr )
hb_dbgSetQuit( ptr );
}
HB_FUNC( HB_DBG_SETTOCURSOR )
{
void * ptr = hb_parptr( 1 );
if( ptr )
hb_dbgSetToCursor( ptr, hb_parc( 2 ), hb_parni( 3 ) );
}
HB_FUNC( HB_DBG_GETEXPRVALUE )
{
void * ptr = hb_parptr( 1 );
if( ptr )
{
PHB_ITEM pItem;
if( ISCHAR( 2 ) )
pItem = hb_dbgGetExpressionValue( hb_parptr( 1 ), hb_parc( 2 ) );
else
pItem = hb_dbgGetWatchValue( hb_parptr( 1 ), hb_parni( 2 ) - 1 );
if( pItem )
{
hb_storl( TRUE, 3 );
hb_itemRelease( hb_itemReturn( pItem ) );
}
else
hb_storl( FALSE, 3 );
}
}
HB_FUNC( HB_DBG_GETSOURCEFILES )
{
void * ptr = hb_parptr( 1 );
if( ptr )
hb_itemRelease( hb_itemReturn( hb_dbgGetSourceFiles( ptr ) ) );
}
HB_FUNC( HB_DBG_ISVALIDSTOPLINE )
{
void * ptr = hb_parptr( 1 );
if( ptr )
hb_retl( hb_dbgIsValidStopLine( ptr, hb_parc( 2 ), hb_parni( 3 ) ) );
}
HB_FUNC( HB_DBG_ADDBREAK )
{
void * ptr = hb_parptr( 1 );
if( ptr )
hb_dbgAddBreak( ptr, hb_parc( 2 ), hb_parni( 3 ), NULL );
}
HB_FUNC( HB_DBG_DELBREAK )
{
void * ptr = hb_parptr( 1 );
if( ptr )
hb_dbgDelBreak( ptr, hb_parni( 2 ) );
}
HB_FUNC( HB_DBG_ADDWATCH )
{
void * ptr = hb_parptr( 1 );
if( ptr )
hb_dbgAddWatch( ptr, hb_parc( 2 ), hb_parl( 3 ) );
}
HB_FUNC( HB_DBG_DELWATCH )
{
void * ptr = hb_parptr( 1 );
if( ptr )
hb_dbgDelWatch( ptr, hb_parni( 2 ) );
}
HB_FUNC( HB_DBG_SETWATCH )
{
void * ptr = hb_parptr( 1 );
if( ptr )
hb_dbgSetWatch( ptr, hb_parni( 2 ), hb_parc( 3 ), hb_parl( 4 ) );
}
Reference in New Issue View Git Blame Copy Permalink