void assign_local ( void )
{
signed long wlen;
bool is_okay;
u8 *savd_pc = pc;
unsigned int savd_lineno = lineno;
wlen = get_word();
if ( wlen <= 0 )
{
warn_unterm(TKERROR, "Locals Assignment", lineno);
return;
}
local_op = "!"; /* Set to Store */
is_okay = handle_local( statbuf);
if( INVERSE(is_okay) )
{
tokenization_error ( TKERROR,
"Cannot apply -> to %s, only to a declared Local.\n", statbuf );
pc = savd_pc;
lineno = savd_lineno;
}
local_op = "@"; /* Reset to Fetch */
}
char *in_what_node(device_node_t *the_node)
{
bool top_node = BOOLVAL( the_node == &top_level_dev_node);
bool curr_node = BOOLVAL( the_node == current_device_node);
bool known_node = BOOLVAL( top_node || curr_node );
bool no_line = BOOLVAL( the_node->line_no == 0);
show_where = INVERSE( no_line );
show_which = known_node;
in_what_line = the_node->line_no;
in_what_file = the_node->ifile_name;
sprintf( in_what_buffr, "in the%s device-node%s",
INVERSE( known_node ) ? ""
: top_node ? " top-level" : " current" ,
no_line ? ".\n"
: known_node ? ", which began" : "" );
return( in_what_buffr);
}
static void conditional_word_in_line( bool alr_ign,
bool exist_test,
bool (*exist_funct)() )
{
if ( get_word_in_line( statbuf) )
{
bool cond = FALSE;
if ( INVERSE( alr_ign) )
{
bool exists = exist_funct( statbuf);
cond = BOOLVAL( exists == exist_test);
}
conditionally_tokenize( cond, alr_ign );
}
}
static operand pslot_to_operand( struct frame* f, int nr_locals, int pidx, bool stackonly ){
assert( f );
assert( f->m );
if( stackonly || pidx >= NR_SPARE_REGS( f ) ){
#if 0
operand r = OP_TARGETDADDR( f->m->sp, 4 * INVERSE( pidx, 2 * nr_locals ) );
#else
operand r = OP_TARGETDADDR( f->m->fp, -(8 + 4 * pidx) );
#endif
return r;
} else {
operand r = OP_TARGETREG( vreg_to_physical_reg( f, pidx ) );
return r;
}
}
void finish_device_vocab( void )
{
bool at_top_level;
dev_vocab_control_struct_check();
/* We never remove the top-level device-node vocabulary,
* so we need to test whether we're about to.
*/
at_top_level = BOOLVAL( current_device_node == &top_level_dev_node );
if ( at_top_level )
{
tokenization_error( TKERROR,
"Encountered %s without corresponding NEW-DEVICE. "
"Resetting definitions since start of tokenization.\n",
statbuf );
}else{
tokenization_error(INFO,
"Encountered %s. Resetting definitions of device node",
statbuf );
started_at( current_device_node->ifile_name,
current_device_node->line_no );
}
/* Now to business... */
delete_device_vocab();
/* Did we just get to the top-level device-node vocabulary
* when we weren't before?
*/
if ( INVERSE(at_top_level) )
{
if ( current_device_node == &top_level_dev_node )
{
tokenization_error(INFO,
"Resuming definitions since start of tokenization.\n" );
}else{
tokenization_error(INFO,
"Resuming definitions of parent device-node" );
started_at( current_device_node->ifile_name,
current_device_node->line_no );
}
}
}
// КАНАЛ 1 -> Инверсия ---------------------------------------------------------------------------------------------------------------------------------------------------
static const Choice mcChanA_Inverse =
{
Item_Choice, &mpChanA, {"Инверсия", "Inverse"},
{
chanInverseRu,
chanInverseEn
},
EmptyFuncBV,
{
{DISABLE_RU, DISABLE_EN},
{ENABLE_RU, ENABLE_EN}
},
(int8*)&INVERSE(A), OnChange_ChanA_Inverse, EmptyFuncVII
};
static void OnChange_ChanA_Inverse(bool active)
{
FPGA_SetRShift(A, RSHIFT_A);
}
// КАНАЛ 1 -> Множитель ---------------------------------------------------------------------------------------------------------------------------------------------------
static const Choice mcChanA_Divider =
{
Item_Choice, &mpChanA, {"Делитель", "Divider"},
{
chanDividerRu,
chanDividerEn
static void conditionally_tokenize( bool cond, bool alr_ign )
{
signed long wlen;
/* Note: The following variables *must* remain within
* the scope of this routine; a distinct instance
* is needed each time this routine is re-entered
* (aka "a nested call").
*/
bool ignoring;
bool first_else = TRUE; /* The "else" we see is the first. */
bool not_done = TRUE;
unsigned int cond_strt_lineno = lineno;
char *cond_strt_ifile_nam = strdup( iname);
ignoring = BOOLVAL( ( cond == FALSE ) || ( alr_ign != FALSE ) );
if ( trace_conditionals )
{
char *cond_val = cond ? "True" : "False" ;
char *cond_junct = alr_ign ? ", but Already " : "; ";
char *processg = ignoring ? "Ignoring" : "Processing" ;
tokenization_error( INFO,
"Tokenization-Condition is %s%s%s.\n",
cond_val, cond_junct, processg);
}
while ( not_done )
{
wlen = get_word();
if ( wlen == 0 )
{
continue;
}
if ( wlen < 0 )
{
tokenization_error( TKERROR,
"Conditional without conclusion; started");
just_where_started( cond_strt_ifile_nam, cond_strt_lineno);
not_done = FALSE ;
continue;
}
if ( is_a_then ( statbuf ) )
{
if ( trace_conditionals )
{
tokenization_error( INFO,
"Concluding Conditional");
just_started_at( cond_strt_ifile_nam, cond_strt_lineno);
}
not_done = FALSE ;
continue;
}
if ( is_an_else( statbuf ) )
{
if ( ! alr_ign )
{
if ( first_else )
{
ignoring = INVERSE( ignoring);
}
}
if ( ! first_else )
{
int severity = ignoring ? WARNING : TKERROR ;
char *the_scop = ignoring ? "(ignored)" : "the" ;
tokenization_error( severity, "Multiple %s directives "
"within %s scope of the Conditional",
strupr(statbuf), the_scop);
just_started_at( cond_strt_ifile_nam, cond_strt_lineno);
}else{
first_else = FALSE;
if ( trace_conditionals )
{
char *when_enc = alr_ign ? "While already" : "Now" ;
char *processg = alr_ign ? "ignoring" :
ignoring ? "Ignoring" : "Processing" ;
char *enc = alr_ign ? ", e" : ". E" ;
tokenization_error( INFO,
"%s %s%sncountered %s belonging to Conditional",
when_enc, processg, enc, strupr(statbuf) );
just_started_at( cond_strt_ifile_nam, cond_strt_lineno);
}
}
continue;
}
/* If we are ignoring source input, for whatever reason, we still
* need to be sensitive to the nesting of Conditional Operators
* and some other commands and directives, as indicated...
*/
if ( ignoring )
{
ignore_one_word( statbuf );
}else{
/* And if we're not ignoring source input, process it! */
tokenize_one_word ( wlen );
}
}
}
