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 );
}
extern void ProcCapture( void )
{
cmd_list *cmds;
const char *start;
size_t len;
const char *old;
char *p;
char *end;
if( !ScanItem( false, &start, &len ) )
Error( ERR_NONE, LIT_ENG( ERR_WANT_COMMAND_LIST ) );
ReqEOC();
cmds = AllocCmdList( start, len );
end = FileName + sizeof( FileName );
p = FileName + PREFIX_LEN;
p = CnvULongHex( TaskId, p, end - p );
*p++ = RemFile.ext_separator;
p = CnvULongDec( FileNum++, p, end - p );
*p = NULLCHAR;
old = ReScan( FileName+PREFIX_LEN );
StdOutNew();
ReScan( old );
cmds->use++;
CaptureOk = true;
PushInpStack( cmds, DoneCapture, false );
TypeInpStack( INP_CAPTURED );
FreeCmdList( cmds );
}
extern void BreakOnSelected( char *item )
{
char *old;
old = ReScan( item );
EvalLValExpr( 1 );
ReScan( old );
BreakOnExprSP( item );
}
void StepIntoFunction( char *func )
{
char *old;
address stop;
old = ReScan( func );
ReqMemAddr( EXPR_CODE, &stop );
ReScan( old );
GoToAddr( stop );
}
void CreateInvokeFile( char *name, void (*rtn)(void) )
{
char *p;
p = ReScan( name );
LogStart();
rtn();
LogEnd();
ReScan( p );
}
mad_status DIGCLIENT MADCliMemExpr( const char *expr, unsigned radix, address *a )
{
const char *old_scan;
unsigned old_radix;
old_radix = SetCurrRadix( radix );
old_scan = ReScan( expr );
EvalExpr( 0 ); /* memory expression */
MakeMemoryAddr( TRUE, EXPR_DATA, a );
SetCurrRadix( old_radix );
ReScan( old_scan );
return( MS_OK );
}
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 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 );
}
OVL_EXTERN void TestExpression( void *_bp )
{
brkp *bp = _bp;
const char *old;
int val;
old = ReScan( bp->condition );
val = ReqExpr();
ReqEOC();
ReScan( old );
if( val ) {
bp->status.b.expr_true = true;
}
}
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 );
}
mad_string ScanCall( void )
{
char *p;
char *q;
const mad_string *type;
char buff[NAM_LEN];
type = MADCallTypeList();
for( ;; ) {
if( *type == MAD_MSTR_NIL ) return( MAD_MSTR_NIL );
MADCliString( *type, sizeof( buff ), buff );
q = buff;
p = TokenStart;
for( ;; ) {
if( !isalnum( *p ) ) {
if( p == TokenStart ) return( MAD_MSTR_NIL );
ReScan( p );
return( *type );
}
if( tolower( *p ) != tolower( *q ) ) break;
++p;
++q;
}
++type;
}
}
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 );
}
unsigned SetCurrRadix( unsigned rad )
{
unsigned old;
old = NewCurrRadix( rad );
ReScan( TokenStart );
return( old );
}
OVL_EXTERN bool DoneCapture( inp_data_handle _cmds, inp_rtn_action action )
{
cmd_list *cmds = _cmds;
const char *old;
switch( action ) {
case INP_RTN_INIT:
ReScan( cmds->buff );
return( true );
case INP_RTN_EOL:
return( false );
case INP_RTN_FINI:
FreeCmdList( cmds );
old = ReScan( LIT_ENG( Empty ) );
StdOutNew();
ReScan( old );
if( CaptureOk ) {
WndTmpFileInspect( FileName );
}
return( true );
}
return( false );
}
OVL_EXTERN bool DoneInvLine( void *inv, inp_rtn_action action )
{
switch( action ) {
case INP_RTN_INIT:
case INP_RTN_EOL:
if( !GetInvkCmd( inv ) ) return( FALSE );
ReScan( ((invokes *)inv)->buff );
return( TRUE );
case INP_RTN_FINI:
Conclude( inv );
return( TRUE );
default:
return( FALSE ); // silence compiler
}
}
void RadixSet( void )
{
unsigned radix;
unsigned old;
old = SetCurrRadix( 10 ); /* radix sets are always base 10 */
radix = ReqExpr();
ReScan( TokenStart );
ReqEOC();
if( radix < 2 || radix > 36 ) {
Error( ERR_NONE, LIT( ERR_BAD_RADIX ), radix );
}
SetCurrRadix( old );
DefaultRadixSet( radix );
}
static mad_type_handle DoScanType( mad_type_kind tk, char *prefix )
{
struct type_name data;
unsigned len;
len = strlen( prefix );
if( memicmp( TokenStart, prefix, len ) != 0 ) {
return( MAD_NIL_TYPE_HANDLE );
}
data.start = TokenStart + len;
data.len = 0;
data.th = MAD_NIL_TYPE_HANDLE;
MADTypeWalk( tk, FindTypeName, &data );
if( data.th == MAD_NIL_TYPE_HANDLE ) return( MAD_NIL_TYPE_HANDLE );
ReScan( data.start + data.len );
return( data.th );
}
void ProcWhile( void )
{
char *start;
unsigned len;
unsigned_64 res;
cmd_list *cmd;
res = ReqU64Expr();
if( !ScanQuote( &start, &len ) || len == 0 ) {
Error( ERR_LOC, LIT( ERR_WANT_COMMAND_LIST ) );
}
ReqEOC();
if( U64Test( &res ) != 0 ) {
cmd = AllocCmdList( start, len );
ReScan( CmdStart );
PushCmdList( cmd );
CopyInpFlags();
FreeCmdList( cmd );
}
}
void InvokeAFile( char *name )
{
ReScan( name );
ProcInvoke();
}
void ProcCall( void )
{
mad_string ctype;
int parm;
const char *results;
address start;
const char *old;
location_list ll;
dig_type_info ti;
dig_type_info *pti;
char *p;
const mad_reg_info **parm_reg;
if( CurrToken == T_DIV ) {
Scan();
ctype = ScanCall();
if( ctype == MAD_MSTR_NIL ) {
Error( ERR_LOC, LIT_ENG( ERR_BAD_CALL_TYPE ) );
}
} else {
ctype = DefCallType;
}
CallExpr( &start );
if( _IsOff( SW_HAVE_SET_CALL ) ) {
FiniCall();
p = TxtBuff;
*p++ = '(';
parm_reg = MADCallParmRegList( ctype, start );
for( parm = 0; parm_reg[parm] != NULL; ++parm ) {
if( parm > 0 ) {
*p++ = ',';
}
p = StrCopy( parm_reg[parm]->name, p );
}
*p++ = ')';
StrCopy( MADCallReturnReg( ctype, start )->name, p );
old = ReScan( TxtBuff );
DoCallSet();
ReScan( old );
}
parm = 0;
results = DefReturn;
if( CurrToken == T_LEFT_PAREN ) {
Scan();
if( CurrToken != T_RIGHT_PAREN ) {
for( ; ; ) {
pti = &ti;
if( CurrToken == T_DIV ) {
Scan();
if( CurrToken == T_DIV ) {
Scan();
/* on stack */
LocationCreate( &ll, LT_INTERNAL, NULL );
pti = NULL;
} else {
GetLocation( &ll, pti );
}
} else {
if( DefParms[parm] == NULL ) {
/* on stack */
LocationCreate( &ll, LT_INTERNAL, NULL );
pti = NULL;
} else {
old = ReScan( DefParms[parm] );
GetLocation( &ll, pti );
ReScan( old );
}
}
PushLocation( &ll, pti );
NormalExpr();
SwapStack( 1 );
++parm;
if( CurrToken != T_COMMA )
break;
Scan();
}
}
Recog( T_RIGHT_PAREN );
results = ScanPos();
if( CurrToken == T_DIV ) {
Scan();
} else if( ScanEOC() ) {
results = DefReturn;
} else {
/* syntax check */
ChkPrintList();
}
}
ReqEOC();
FreezeRegs();
if( PerformExplicitCall( start, ctype, parm ) && results != NULL ) {
old = ReScan( results );
if( Spawn( CallResults ) == 0 ) {
ReScan( old );
}
}
UnFreezeRegs();
FreePgmStack( false );
}
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 );
}
static unsigned MechGet( unsigned select, unsigned parm )
{
unsigned result;
DIPHDL( cue, ch );
sym_list *sym;
address addr;
unsigned old;
char *save_scan;
char *mod_name;
unsigned mod_len;
unsigned mod_spec_token;
result = FALSE;
switch( select ) {
case 0: /* init */
memset( &CurrGet, 0, sizeof( CurrGet ) );
CurrGet.li.mod = NO_MOD;
if( _IsOn( SW_CASE_SENSITIVE ) ) {
CurrGet.li.case_sensitive = TRUE;
} else {
CurrGet.li.case_sensitive = FALSE;
}
break;
case 1: /* fini */
switch( CurrGet.kind ) {
case GET_NAME:
PushName( &CurrGet.li );
break;
case GET_OPERATOR:
CurrGet.li.type = ST_OPERATOR;
PushName( &CurrGet.li );
break;
case GET_LNUM:
switch( FindACue( ch ) ) {
case SR_EXACT:
break;
case SR_CLOSEST:
if( ClosestLineOk ) break;
default:
Error( ERR_NONE, LIT( ERR_NO_CODE ), CurrGet.li.name.len );
}
PushAddr( CueAddr( ch ) );
break;
}
break;
case 2: /* mod curr */
case 3: /* mod name lookup */
//NYI: temporary gunk
CurrGet.multi_module = TRUE;
CurrGet.li.mod = NO_MOD;
save_scan = ScanPos();
ReScan( "@" );
mod_spec_token = CurrToken;
ReScan( save_scan );
if( CurrToken == T_NAME ) {
mod_name = NamePos();
mod_len = NameLen();
Scan();
} else {
mod_name = NULL;
mod_len = 0;
}
if( CurrToken == mod_spec_token ) {
if( select == 2 ) {
CurrGet.li.mod = ImagePrimary()->dip_handle;
if( CurrGet.li.mod == NO_MOD ) {
CurrGet.li.mod = ILL_MOD; /* cause lookup to fail */
}
} else {
CurrGet.li.mod = LookupImageName( CurrGet.li.name.start,
CurrGet.li.name.len );
if( CurrGet.li.mod == NO_MOD ) {
#define ANY_IMAGE_NAME "_anyimage"
#define ANY_IMAGE_NAME_LEN (sizeof(ANY_IMAGE_NAME)-1)
if( CurrGet.li.name.len != ANY_IMAGE_NAME_LEN
|| memicmp( CurrGet.li.name.start, ANY_IMAGE_NAME, ANY_IMAGE_NAME_LEN ) != 0 ) {
Error( ERR_NONE, LIT( ERR_NO_IMAGE ), CurrGet.li.name.start,
CurrGet.li.name.len );
} else {
CurrGet.any_image = TRUE;
}
}
}
CurrGet.li.name.start = mod_name;
CurrGet.li.name.len = mod_len;
Scan();
} else {
ReScan( save_scan );
}
if( CurrGet.li.name.start != NULL ) {
CurrGet.li.mod = LookupModName( CurrGet.li.mod,
CurrGet.li.name.start, CurrGet.li.name.len );
if( CurrGet.li.mod == NO_MOD ) {
Error( ERR_NONE, LIT( ERR_NO_MODULE ), CurrGet.li.name.start,
CurrGet.li.name.len );
}
CurrGet.multi_module = FALSE;
} else if( !CurrGet.any_image && CurrGet.li.mod == NO_MOD ) {
CurrGet.li.mod = CodeAddrMod;
CurrGet.multi_module = FALSE;
}
break;
case 4: /* file scope */
CurrGet.li.file_scope = TRUE;
break;
case 5: /* given scope */
CurrGet.li.file_scope = FALSE;
break;
case 6: /* scope lookup */
CurrGet.li.scope.start = CurrGet.li.name.start;
CurrGet.li.scope.len = CurrGet.li.name.len;
break;
case 7: /* get name >>bool */
if( CurrToken == T_NAME ) {
CurrGet.kind = GET_NAME;
CurrGet.li.name.start = NamePos();
CurrGet.li.name.len = NameLen();
Scan();
result = TRUE;
}
break;
case 8: /* get operator name */
CurrGet.kind = GET_OPERATOR;
CurrGet.li.name.start = NamePos();
CurrGet.li.name.len = NameLen();
Scan();
break;
case 9: /* get line number >>bool */
if( CurrToken == T_LEFT_BRACE ) {
size_t len;
/* Get a specfic file name for the module */
ScanQuote( &CurrGet.li.source.start, &len );
CurrGet.li.source.len = len;
}
if( CurrToken == T_INT_NUM ) {
unsigned_64 tmp;
result = TRUE;
CurrGet.kind = GET_LNUM;
old = SetCurrRadix( 10 );
tmp = IntNumVal();
CurrGet.li.name.len = U32FetchTrunc( tmp );
Scan();
SetCurrRadix( old );
}
break;
case 10: /* GetDtorName >>bool */
if( CurrToken == T_NAME ) {
CurrGet.kind = GET_NAME;
CurrGet.li.name.start = NamePos();
CurrGet.li.name.len = NameLen();
CurrGet.li.type = ST_DESTRUCTOR;
addr = Context.execution;
sym = LookupSymList( SS_SCOPED, &addr, FALSE, &CurrGet.li );
if( sym != NULL ) {
PurgeSymHandles();
Scan();
result = TRUE;
} else {
CurrGet.li.type = ST_NONE;
}
}
break;
case 11: /* GetSetNameType(symbol_type) */
CurrGet.li.type = parm;
break;
case 12: /* GetQueryName >>bool */
CurrGet.kind = GET_NAME;
addr = Context.execution;
sym = LookupSymList( SS_SCOPED, &addr, FALSE, &CurrGet.li );
if( sym != NULL ) {
PurgeSymHandles();
result = TRUE;
} else {
CurrGet.li.type = ST_NONE;
}
break;
case 13: /* GetAddScope */
if( CurrGet.li.scope.len == 0 ) {
CurrGet.li.scope = CurrGet.li.name;
} else {
CurrGet.li.scope.len = (CurrGet.li.name.start-CurrGet.li.scope.start)
+ CurrGet.li.name.len;
}
break;
}
return( result );
}
void FileMgr::Init()
{
ReScan();
}
void ScanExpr( void *tbl )
{
ExprTokens = tbl;
ReScan( TokenStart );
}