extern bool WndEvalInspectExpr( char *item, bool pop )
/********************************************************/
{
char *old;
char buff[12],*p;
bool rc;
if( ispunct(item[0]) &&
( item[1] == '\0' || ( ispunct( item[1] ) && item[2] == '\0' ) ) ) {
// nyi - pui - use SSL
p = StrCopy( item, StrCopy( "operator", buff ) );
if( item[0] == '[' && item[1] == '\0' ) {
StrCopy( "]", p );
} else if( item[0] == '(' && item[1] == '\0' ) {
StrCopy( ")", p );
}
old = ReScan( buff );
} else {
old = ReScan( item );
}
_SwitchOn( SW_CALL_FATAL );
_SwitchOn( SW_ERR_IN_TXTBUFF );
_SwitchOn( SW_NO_DISAMBIGUATOR );
rc = ( Spawn( DoLValExpr ) == 0 );
_SwitchOff( SW_CALL_FATAL );
_SwitchOff( SW_NO_DISAMBIGUATOR );
_SwitchOff( SW_ERR_IN_TXTBUFF );
ReScan( old );
if( pop && rc ) PopEntry();
return( rc );
}
void CheckMADChange( void )
{
mad_status ms;
mad_type_info mti;
if( MADActiveSet( SysConfig.mad ) != SysConfig.mad ) {
if( MADLoaded( SysConfig.mad ) != MS_OK ) {
ms = MADLoad( SysConfig.mad );
if( ms != MS_OK ) {
ReportMADFailure( ms );
}
}
DbgUpdate( UP_MAD_CHANGE );
ResizeTraceData();
ResizeRegData();
PendingToggles();
if( MADCallStackGrowsUp() == MS_OK ) {
_SwitchOn( SW_STACK_GROWS_UP );
} else {
_SwitchOff( SW_STACK_GROWS_UP );
}
GetMADTypeDefault( MTK_ADDRESS, &mti );
if( mti.a.seg.bits != 0 ) {
_SwitchOn( SW_HAVE_SEGMENTS );
} else {
_SwitchOff( SW_HAVE_SEGMENTS );
}
SetMADMenuItems();
ClearMachineDataCache();
}
}
void DIGCLIENT MADCliNotify( mad_notify_type nt, const void *d )
{
switch( nt ) {
case MNT_ERROR:
MADStatus = *(mad_status *)d;
break;
case MNT_MODIFY_REG:
DbgUpdate( UP_REG_CHANGE );
break;
case MNT_MODIFY_IP:
DbgUpdate( UP_CSIP_CHANGE );
break;
case MNT_MODIFY_SP:
case MNT_MODIFY_FP:
break;
case MNT_EXECUTE_TOUCH_SCREEN_BUFF:
_SwitchOn( SW_TOUCH_SCREEN_BUFF );
break;
case MNT_EXECUTE_LONG:
_SwitchOn( SW_EXECUTE_LONG );
break;
case MNT_REDRAW_DISASM:
DbgUpdate( UP_ASM_RESIZE );
break;
case MNT_REDRAW_REG:
DbgUpdate( UP_REG_RESIZE );
break;
}
}
bool ScanSelectedExpr( char *expr )
{
char *old;
bool rc;
old = ReScan( expr );
_SwitchOn( SW_ERR_IN_TXTBUFF );
_SwitchOn( SW_NO_DISAMBIGUATOR );
rc = ( Spawn( NormalExpr ) == 0 );
_SwitchOff( SW_NO_DISAMBIGUATOR );
_SwitchOff( SW_ERR_IN_TXTBUFF );
ReScan( old );
return( rc );
}
void ProcFlip( void )
{
const char *old;
uint_16 wait;
wait = 0;
if( !ScanEOC() ) {
old = ScanPos();
switch( ScanCmd( "ON\0OFf\0" ) ) {
case 0:
ReqEOC();
_SwitchOn( SW_FLIP );
return;
case 1:
ReqEOC();
_SwitchOff( SW_FLIP );
return;
default:
ReScan( old );
wait = (uint_16)ReqExpr();
ReqEOC();
break;
}
}
Flip( wait );
}
void ProcFlip( void )
{
char *old;
unsigned wait;
unsigned cmd;
wait = 0;
if( !ScanEOC() ) {
old = ScanPos();
cmd = ScanCmd( OnOffNameTab );
switch( cmd ) {
case 1:
ReqEOC();
_SwitchOn( SW_FLIP );
return;
case 2:
ReqEOC();
_SwitchOff( SW_FLIP );
return;
default:
ReScan( old );
wait = ReqExpr();
ReqEOC();
break;
}
}
Flip( wait );
}
bool ProcSysOption( const char *start, unsigned len, int pass )
{
unsigned long num;
pass=pass;
switch( Lookup( SysOptNameTab, start, len ) ) {
case OPT_NOSNOW:
_SwitchOn( SW_NOSNOW );
break;
case OPT_CHECKSIZE:
num = GetMemory();
if( num < 32*1024UL )
num = 32*1024UL;
if( num > 640*1024UL )
num = 640*1024UL;
CheckSize = num / 16; /* Checksize is in paragraphs */
break;
case OPT_SIZE:
num = GetMemory();
if( num > 150*1024UL )
num = 150*1024UL;
OvlAreaSize = num / 16; /* OvlAreaSize is in paragraphs */
break;
default:
return( false );
}
return( true );
}
void DebugMain( void )
{
bool save;
GrabHandlers();
SysFileInit();
WndMemInit();
InitLiterals();
InitLocalInfo();
ProcCmd();
Spawn( DebugInit );
DUIFingOpen();
DUIFreshAll();
LoadProg();
save = DUIStopRefresh( TRUE );
FreezeInpStack();
_SwitchOn( SW_RUNNING_PROFILE );
Spawn( Profile ); /* run profile command file */
_SwitchOff( SW_RUNNING_PROFILE );
PushInitCmdList();
DUIStopRefresh( save );
DUIFingClose();
DUIShow();
}
static image_entry *CreateImage( const char *exe, const char *symfile )
{
image_entry *image;
bool local;
const char *curr_name;
unsigned curr_len;
const char *this_name;
unsigned this_len;
char_ring *curr;
open_access ind;
if( exe != NULL && symfile == NULL ) {
local = false;
this_name = SkipPathInfo( exe, OP_REMOTE );
this_len = ExtPointer( exe, OP_REMOTE ) - exe;
for( curr = LocalDebugInfo; curr != NULL; curr = curr->next ) {
curr_name = SkipPathInfo( curr->name, OP_LOCAL );
curr_name = RealFName( curr_name, &ind );
if( curr_name[0] == '@' && curr_name[1] == 'l' )
curr_name += 2;
curr_len = ExtPointer( curr_name, OP_LOCAL ) - curr_name;
local = ( this_len == curr_len && strnicmp( this_name, curr_name, this_len ) == 0 );
if( local ) {
symfile = curr->name;
break;
}
}
}
_SwitchOn( SW_ERROR_RETURNS );
image = DoCreateImage( exe, symfile );
_SwitchOff( SW_ERROR_RETURNS );
return( image );
}
void ProcCmd( void )
{
char buff[TXT_LEN];
unsigned screen_mem;
size_t have_env;
int pass;
MemSize = MIN_MEM_SIZE;
TrapParms = NULL;
_SwitchOn( SW_LOAD_SYMS );
_SwitchOn( SW_USE_MOUSE );
ProcSysOptInit();
DUIScreenOptInit();
have_env = DUIEnvLkup( EXENAME, buff, sizeof( buff ) );
for( pass = 1; pass <= 2; ++pass ) {
if( have_env ) {
GetArg = &GetEnvArg;
CurrArgc = 0;
CurrArgp = buff;
ProcOptList( pass );
if( CurrChar != ARG_TERMINATE ) {
OptError( LIT_ENG( STARTUP_Expect_End_Env_Str ) );
}
}
GetArg = &GetCmdArg;
CurrArgc = 0;
CurrArgp = GetCmdArg( 0 );
if( CurrArgp != NULL ) {
ProcOptList( pass );
if( pass == 2 ) {
SetCmdArgStart( CurrArgc, CurrArgp );
}
}
if( pass == 1 ) {
screen_mem = DUIConfigScreen();
if( MemSize + screen_mem >= MemSize ) {
MemSize += screen_mem;
} else {
MemSize = ~0;
}
SysSetMemLimit();
TrapParms = DupStr( "std" );
InvokeFile = DupStr( "" );
}
}
}
static void RunRequest( int req )
{
if( _IsOn( SW_TASK_RUNNING ) )
return;
WaitForSingleObject( Requestdonesem, INFINITE ); // wait for last request to finish
Req = req;
_SwitchOn( SW_TASK_RUNNING );
ReleaseSemaphore( Requestsem, 1, NULL ); // tell worker to go
}
/*
* CallExpr -- get a call expression
*/
void CallExpr( address *out_val )
{
unsigned old;
old = SetCurrRadix( 16 );
_SwitchOn( SW_EXPR_IS_CALL );
EvalExpr( 0 ); /* call expression */
MakeMemoryAddr( TRUE, EXPR_CODE, out_val );
SetCurrRadix( old );
}
void DebugInit( void )
{
NestedCallLevel = 0;
UpdateFlags = 0;
_SwitchOn( SW_ERROR_STARTUP );
_SwitchOn( SW_CHECK_SOURCE_EXISTS );
SET_NIL_ADDR( NilAddr );
TxtBuff = &DbgBuffers[0];
*TxtBuff = '\0';
NameBuff = &DbgBuffers[TXT_LEN+1];
*NameBuff = '\0';
CurrRadix = DefRadix = 10;
DbgLevel = MIX;
ActiveWindowLevel = MIX;
_SwitchOn( SW_BELL );
_SwitchOn( SW_FLIP );
_SwitchOn( SW_RECURSE_CHECK );
_SwitchOff( SW_ADDING_SYMFILE );
_SwitchOff( SW_TASK_RUNNING );
RecordInit();
LogInit();
InitMADInfo();
InitMachState();
PathInit();
InitDbgInfo();
InitTrap( TrapParms );
if( !LangSetInit() ) {
FiniTrap();
StartupErr( LIT_ENG( STARTUP_Loading_PRS ) );
}
if( !InitCmd() ) {
FiniTrap();
StartupErr( LIT_ENG( ERR_NO_MEMORY ) );
}
InitScan();
InitLook();
InitBPs();
InitSource();
InitDLLList();
DUIInit();
InitHook();
VarDisplayInit();
}
bool ProcInput( void )
{
bool ret;
_SwitchOn( SW_WND_DOING_INPUT );
ret = Spawn( DoProcPending );
DUIProcPendingPaint();
_SwitchOff( SW_WND_DOING_INPUT );
return( ret );
}
void RunRequest( int req )
{
ULONG ulCount;
if( _IsOn( SW_TASK_RUNNING ) ) return;
DosWaitEventSem( Requestdonesem, SEM_INDEFINITE_WAIT ); // wait for last request to finish
DosResetEventSem( Requestdonesem, &ulCount );
Req = req;
_SwitchOn( SW_TASK_RUNNING );
DosPostEventSem( Requestsem ); // tell worker to go
}
void SetProgState( unsigned run_conditions )
{
ReadDbgRegs();
if( run_conditions & COND_THREAD_EXTRA ) {
_SwitchOn( SW_THREAD_EXTRA_CHANGED );
}
if( run_conditions & COND_THREAD ) {
DbgRegs->tid = RemoteSetThread( 0 );
CheckForNewThreads( TRUE );
}
if( run_conditions & COND_ALIASING ) CheckSegAlias();
}
static bool DlgDoScan( char *str, void *value, void (*rtn)(void*) )
{
char *old;
bool ok;
old = ReScan( str );
_SwitchOn( SW_ERR_IN_TXTBUFF );
FreezeStack();
ok = ( SpawnP( rtn, value ) == 0 );
UnFreezeStack( FALSE );
_SwitchOff( SW_ERR_IN_TXTBUFF );
ReScan( old );
return( ok );
}
bool ProcSysOption( const char *start, unsigned len, int pass )
{
pass=pass;
switch( Lookup( SysOptNameTab, start, len ) ) {
case OPT_NOSNOW:
break;
case OPT_POPUPS:
_SwitchOn( SW_DETACHABLE_WINDOWS );
break;
default:
return( false );
}
return( true );
}
void ProcPaint( void )
{
wnd_class wndcls;
gui_colour fore;
gui_colour back;
gui_colour_set *set;
bool dialog;
int attr;
dialog = FALSE;
wndcls = WND_NO_CLASS;
if( ScanStatus() ) {
attr = 0;
} else if( ScanCmd( "DIalog\0" ) == 0 ) {
dialog = TRUE;
attr = ScanAttr( DlgAttrMap, ArraySize( DlgAttrMap ) );
} else {
wndcls = ReqWndName();
attr = ScanAttr( AttrMap, ArraySize( AttrMap ) );
}
fore = ScanColour();
ScanCmd( "On\0" );
back = ScanColour();
ReqEOC();
if( attr < 0 )
return;
if( wndcls == WND_NO_CLASS ) {
if( dialog ) {
GUIGetDialogColours( WndDlgColours );
set_dlg_attr( (gui_dlg_attr)attr, fore, back );
GUISetDialogColours( WndDlgColours );
} else {
WndStatusColour.fore = fore;
WndStatusColour.back = back;
if( WndHaveStatusWindow() ) {
WndCloseStatusWindow();
WndCreateStatusWindow( &WndStatusColour );
}
}
} else {
set = WndClassColour[wndcls];
if( set == NULL ) {
set = WndAlloc( sizeof( WndColours ) );
memcpy( set, WndColours, sizeof( WndColours ) );
WndClassColour[wndcls] = set;
}
set_wndcls_attr( (wnd_attr)attr, set, fore, back, ( wndcls == WND_ALL ) );
_SwitchOn( SW_PENDING_REPAINT );
}
}
void FontChange( void )
{
wnd_class_wv wndclass;
char *text;
text = GUIGetFontFromUser( WndFontInfo[WND_ALL] );
if( text == NULL )
return;
for( wndclass = 0; wndclass < WND_NUM_CLASSES; ++wndclass ) {
SetFont( wndclass, NULL );
}
SetFont( WND_ALL, text );
_SwitchOn( SW_PENDING_REPAINT );
}
unsigned Execute( bool tracing, bool do_flip )
{
unsigned conditions;
bool stack_cmds;
static unsigned executing = 0;
if( !CheckStackPos() )
return( COND_USER );
if( !AdvMachState( ACTION_EXECUTE ) )
return( COND_USER );
if( executing == 0 ) {
++executing;
HookNotify( true, HOOK_EXEC_START );
--executing;
}
/* get rid of useless pending input information */
for( ;; ) {
if( CurrToken != T_LINE_SEPARATOR )
break;
if( InpStack == NULL )
break;
if( InpStack->type & (INP_HOLD|INP_STOP_PURGE) )
break;
if( InpStack->rtn( InpStack->handle, INP_RTN_EOL ) )
continue;
PopInpStack();
}
_SwitchOff( SW_TRAP_CMDS_PUSHED );
conditions = ExecProg( tracing, do_flip, true );
SetCodeDot( GetRegIP() );
stack_cmds = true;
if( tracing && (conditions & COND_BREAK) )
stack_cmds = false;
if( ReportTrap( conditions, stack_cmds ) ) {
_SwitchOn( SW_TRAP_CMDS_PUSHED );
}
if( executing == 0 ) {
++executing;
HookNotify( true, HOOK_EXEC_END );
--executing;
}
if( conditions & COND_TERMINATE ) {
HookNotify( true, HOOK_PROG_END );
}
return( conditions );
}
bool GetBPSymAddr( brkp *bp, address *addr )
{
char buff[TXT_LEN],*p;
bool rc;
p = buff;
if( bp->image_name != NULL ) {
p = StrCopy( bp->image_name, p );
p = StrCopy( "@", p );
}
p = StrCopy( bp->mod_name, p );
p = StrCopy( "@", p );
p = StrCopy( bp->sym_name, p );
_SwitchOn( SW_AMBIGUITY_FATAL );
rc = DlgScanCodeAddr( buff, addr );
_SwitchOff( SW_AMBIGUITY_FATAL );
return( rc );
}
void ProcFont( void )
{
wnd_class_wv wndclass;
const char *start;
size_t len;
wnd_class_wv wndclass1;
wndclass = ReqWndName();
if( !ScanItem( false, &start, &len ) )
return;
ReqEOC();
if( wndclass == WND_ALL ) {
for( wndclass1 = 0; wndclass1 < WND_NUM_CLASSES; ++wndclass1 ) {
SetFont( wndclass1, NULL );
}
}
SetFont( wndclass, GUIDupStrLen( start, len ) );
_SwitchOn( SW_PENDING_REPAINT );
}
void ReportMADFailure( mad_status ms )
{
mad_handle old;
char buff[TXT_LEN];
if( SysConfig.mad == MAD_NIL ) {
/* we're in deep do do */
StartupErr( LIT_ENG( LMS_RECURSIVE_MAD_FAILURE ) );
}
old = SysConfig.mad;
MADNameFile( old, buff, sizeof( buff ) );
SysConfig.mad = MAD_NIL;
/* this deregisters the MAD, and sets the active one to the dummy */
MADRegister( old, NULL, NULL );
_SwitchOn( SW_ERROR_RETURNS );
switch( ms & ~MS_ERR ) {
case MS_UNREGISTERED_MAD:
Error( ERR_NONE, LIT_ENG( LMS_UNREGISTERED_MAD ), old );
break;
case MS_INVALID_MAD_VERSION:
Error( ERR_NONE, LIT_ENG( LMS_INVALID_MAD_VERSION ), buff );
break;
case MS_INVALID_STATE:
Error( ERR_INTERNAL, "MAD state" );
break;
case MS_FOPEN_FAILED:
Error( ERR_NONE, LIT_ENG( ERR_FILE_NOT_OPEN ), buff );
break;
case MS_FREAD_FAILED:
case MS_FSEEK_FAILED:
Error( ERR_NONE, LIT_ENG( LMS_FREAD_FAILED ), buff );
break;
case MS_NO_MEM:
Error( ERR_NONE, LIT_ENG( ERR_NO_MEMORY ) );
break;
case MS_INVALID_MAD:
default:
Error( ERR_NONE, LIT_ENG( LMS_INVALID_MAD ), buff );
break;
}
_SwitchOff( SW_ERROR_RETURNS );
}
static bool DoStackOrHistory( int id )
{
int resp;
resp = CTL_STK_CANCEL;
ResDlgOpen( &StkOrHistoryEvent, &resp, id );
switch( resp ) {
case CTL_STK_CANCEL:
_SwitchOn( SW_EXECUTE_ABORTED );
return( FALSE );
case CTL_STK_YES:
if( id == DIALOG_STACK ) {
LastStackPos();
} else {
LastMachState();
}
break;
}
return( TRUE );
}
static bool DoStackOrHistory( res_name_or_id dlg_id )
{
gui_ctl_id resp;
resp = CTL_STK_CANCEL;
ResDlgOpen( &StkOrHistoryEvent, &resp, dlg_id );
switch( resp ) {
case CTL_STK_CANCEL:
_SwitchOn( SW_EXECUTE_ABORTED );
return( false );
case CTL_STK_YES:
if( dlg_id == GUI_MAKEINTRESOURCE( DIALOG_STACK ) ) {
LastStackPos();
} else {
LastMachState();
}
break;
}
return( true );
}
bool LoadDeferredSymbols( void )
{
image_entry *image;
bool rc = false;
bool defer;
defer = _IsOn( SW_DEFER_SYM_LOAD );
_SwitchOff( SW_DEFER_SYM_LOAD );
for( image = DbgImageList; image != NULL; image = image->link ) {
if( image->deferred_symbols ) {
if( ReLoadImgSymInfo( image ) ) {
InitImageInfo( image );
image->deferred_symbols = false;
rc = true;
}
}
}
if( defer )
_SwitchOn( SW_DEFER_SYM_LOAD );
return( rc );
}
void ReportTask( task_status task, error_idx code )
{
switch( task ) {
case TASK_NEW:
_SwitchOn( SW_HAVE_TASK );
DUIStatusText( LIT_ENG( New_Task ) );
DUIDlgTxt( LIT_ENG( New_Task ) );
break;
case TASK_NOT_LOADED:
_SwitchOff( SW_HAVE_TASK );
Format( TxtBuff, LIT_ENG( Task_Not_Loaded ), code );
DUIMsgBox( TxtBuff );
RingBell();
RingBell();
break;
case TASK_NONE:
_SwitchOff( SW_HAVE_TASK );
DUIStatusText( LIT_ENG( No_Task ) );
DUIDlgTxt( LIT_ENG( No_Task ) );
break;
}
}
void ProcGo( void )
{
address start;
address stop;
bool have_start;
bool have_stop;
bool have_keep;
bool doflip;
bool flip_on;
bool until;
unsigned conditions;
int count;
have_keep = FALSE;
doflip = TRUE;
until = FALSE;
while( CurrToken == T_DIV ) {
Scan();
switch( ScanCmd( GoOptionTab ) ) {
case KEEP:
have_keep = TRUE;
break;
case NOFLIP:
doflip = FALSE;
break;
case UNTIL:
until = TRUE;
break;
default:
Error( ERR_LOC, LIT( ERR_BAD_OPTION ), GetCmdName( CMD_GO ) );
}
}
if( !have_keep ) TraceKill();
NullStatus( &DbgTmpBrk );
start = GetRegIP();
have_stop = FALSE;
have_start = FALSE;
if( !ScanEOC() ) {
stop = start;
ReqMemAddr( EXPR_GIVEN, &stop );
if( CurrToken == T_COMMA ) {
start = stop;
have_start = TRUE;
Scan();
if( !ScanEOC() ) {
ReqMemAddr( EXPR_GIVEN, &stop );
have_stop = TRUE;
}
} else {
have_stop = TRUE;
}
}
ReqEOC();
count = 0;
do {
if( have_stop ) {
if( have_keep ) {
if( UserTmpBrk.status.b.has_address ) {
NullStatus( &UserTmpBrk );
UserTmpBrk.status.b.has_address = TRUE;
} else {
NullStatus( &UserTmpBrk );
}
Error( ERR_NONE, LIT( ERR_INCONSISTENT_GO ) );
}
SetTempBreak( stop );
} else if( have_keep ) {
if( UserTmpBrk.status.b.has_address ) {
UserTmpBrk.status.b.active = TRUE;
}
} else {
NullStatus( &UserTmpBrk );
}
if( have_start ) {
RecordSetRegIP( start );
}
flip_on = _IsOn( SW_FLIP );
if( !doflip ) {
_SwitchOff( SW_FLIP );
}
conditions = Go( doflip );
if( flip_on ) _SwitchOn( SW_FLIP );
if( UserTmpBrk.status.b.has_address ) {
NullStatus( &UserTmpBrk );
UserTmpBrk.status.b.has_address = TRUE;
} else {
NullStatus( &UserTmpBrk );
}
} while( until && (conditions & COND_BREAK) && AddrComp( stop, GetRegIP() ) != 0 && ++count < 100 );
}
static unsigned MechMisc( unsigned select, unsigned parm )
{
long value;
unsigned result = 0;
mad_type_info mti;
switch( select ) {
case 0:
ExprAddrDepth += parm;
result = ExprAddrDepth;
break;
case 1:
if( _IsOn( SW_EXPR_IS_CALL ) && ExprAddrDepth == 0 ) {
result = TRUE;
} else {
result = FALSE;
}
break;
case 2:
SkipCount += parm;
break;
case 3:
result = SkipCount;
break;
case 4:
//never called
break;
case 5:
if( ScanSavePtr >= MAX_SCANSAVE_PTRS )
Error( ERR_INTERNAL, LIT( ERR_TOO_MANY_SCANSAVE ) );
CurrScan[ScanSavePtr++] = ScanPos();
break;
case 6:
if( ScanSavePtr <= 0 ) Error( ERR_INTERNAL, LIT( ERR_TOO_MANY_SCANRESTORE ) );
ReScan( CurrScan[--ScanSavePtr] );
break;
case 7:
if( ScanSavePtr <= 0 ) Error( ERR_INTERNAL, LIT( ERR_TOO_MANY_SCANRESTORE ) );
--ScanSavePtr;
break;
case 8:
if( parm ) { /* start scan string */
scan_string = TRUE;
ReScan( ScanPos() );
} else { /* end scan string */
scan_string = FALSE;
ReScan( ScanPos() );
}
break;
case 9:
ReScan( ScanPos() + (int)parm );
break;
case 10:
AddChar();
break;
case 11:
AddCEscapeChar();
break;
case 12:
AddActualChar( '\0' );
break;
case 13:
ScanCCharNum = parm;
break;
case 14:
if( NestedCallLevel == MAX_NESTED_CALL - 1 ) {
Error( ERR_NONE, LIT( ERR_TOO_MANY_CALLS ) );
} else {
PgmStackUsage[ ++NestedCallLevel ] = 0;
}
break;
case 15:
RValue( ExprSP );
ConvertTo( ExprSP, TK_INTEGER, TM_SIGNED, 4 );
value = U32FetchTrunc( ExprSP->v.uint ) - 1;
PopEntry();
if( ExprSP->info.kind == TK_STRING ) {
if( value < 0 || value >= ExprSP->info.size ) {
Error( ERR_NONE, LIT( ERR_BAD_SUBSTRING_INDEX ) );
}
LocationAdd( &ExprSP->v.string.loc, value*8 );
ExprSP->info.size -= value;
ExprSP->v.string.ss_offset = value;
} else {
Error( ERR_NONE, LIT( ERR_ILL_TYPE ) );
}
break;
case 16:
RValue( ExprSP );
ConvertTo( ExprSP, TK_INTEGER, TM_SIGNED, 4 );
value = U32FetchTrunc( ExprSP->v.sint ) - 1;
PopEntry();
if( ExprSP->info.kind == TK_STRING ) {
value -= ExprSP->v.string.ss_offset;
if( value < 0 || value >= ExprSP->info.size ) {
Error( ERR_NONE, LIT( ERR_BAD_SUBSTRING_INDEX ) );
}
ExprSP->info.size = value;
} else {
Error( ERR_NONE, LIT( ERR_ILL_TYPE ) );
}
break;
case 17:
EvalSubstring = parm;
if( parm ) ExprSP->v.string.ss_offset = 0;
break;
case 18:
result = EvalSubstring;
break;
case 19:
FreePgmStack( TRUE );
break;
case 20:
switch( parm ) { // nyi - begin temp
case SSL_CASE_SENSITIVE:
_SwitchOn( SW_CASE_SENSITIVE );
break;
case SSL_SIDE_EFFECT:
_SwitchOn( SW_SIDE_EFFECT );
break;
//case SSL_32_BIT:
// _SwitchOn( SW_32_BIT );
// break;
}
break;
case 21:
switch( parm ) {
case SSL_CASE_SENSITIVE:
_SwitchOff( SW_CASE_SENSITIVE );
break;
case SSL_SIDE_EFFECT:
_SwitchOff( SW_SIDE_EFFECT );
break;
//case SSL_32_BIT:
// _SwitchOff( SW_32_BIT );
// break;
}
break;
case 22:
switch( parm ) {
case SSL_CASE_SENSITIVE:
result = _IsOn( SW_CASE_SENSITIVE );
break;
case SSL_SIDE_EFFECT:
result = _IsOn( SW_SIDE_EFFECT );
break;
case SSL_32_BIT:
GetMADTypeDefault( MTK_INTEGER, &mti );
result = (mti.b.bits >= 32);
break;
}
break;
case 23: // nyi - end temp
MarkArrayOrder( parm );
break;
case 24:
StartSubscript();
break;
case 25:
AddSubscript();
break;
case 26:
EndSubscript();
break;
}
return( result );
}
