static void deQueue // TAKE (FIFO) INSTRUCTION FROM QUEUE
( void )
{
PP_INS* ins; // - queued instruction
ins = ins_queue->next;
DbgVerify( NULL != ins, "Empty instruction queue" );
RingPrune( &ins_queue, ins );
IfDbgToggle( browse ) {
DbgStmt( printf( "dequeued %s %x\n "
, DbgIcOpcode( ins->opcode )
, ins->parm ) );
DbgStmt( DbgDumpTokenLocn( &ins->locn ) );
DbgStmt( printf( "\n" ) );
}
writeIns( ins->opcode, ins->parm, &ins->locn );
CarveFree( carvePpIns, ins );
}
static void queue // PLACE INSTRUCTION ON QUEUE
( CGINTEROP opcode // - opcode
, void const * parm // - parm for instruction
, TOKEN_LOCN const * locn ) // - location for instruction
{
if( cursor.src_file == locn->src_file
&& NULL != cursor.src_file
&& opcode != IC_BR_SRC_END ) {
writeIns( opcode, parm, locn );
} else {
PP_INS* ins = RingCarveAlloc( carvePpIns, &ins_queue );
ins->opcode = opcode;
ins->parm = parm;
TokenLocnAssign( ins->locn, *locn );
IfDbgToggle( browse ) {
DbgStmt( printf( "queued %s %x\n ", DbgIcOpcode( opcode ), parm ) );
DbgStmt( DbgDumpTokenLocn( locn ) );
DbgStmt( printf( "\n" ) );
}
}
}
void DumpCgFront( // DUMP GENERATED CODE
const char *prefix, // - name added to print line
DISK_ADDR disk_blk, // - disk block
DISK_OFFSET offset, // - disk offset
void *instruction ) // - intermediate code
{
CGINTER *ins; // - instruction
char *opcode; // - opcode
unsigned uvalue; // - value with opcode
VBUF vbuf;
ins = instruction;
opcode = DbgIcOpcode( ins->opcode );
if( ins->opcode == IC_EOF ) {
uvalue = 0;
} else {
uvalue = ins->value.uvalue;
}
switch( optypes[ ins->opcode ] ) {
case DBG_OPCODE_SYM :
printf( F_NAME
" " F_BUF_FMT
" " F_INSTR
" " F_HEX_4
" " F_NAME F_EOL
, prefix
, disk_blk, offset
, opcode
, uvalue
, DbgSymNameFull( ins->value.pvalue, &vbuf ) );
VbufFree( &vbuf );
break;
case DBG_OPCODE_TYP :
{ VBUF fmt_prefix, fmt_suffix;
FormatType( ins->value.pvalue, &fmt_prefix, &fmt_suffix );
printf( F_NAME
" " F_BUF_FMT
" " F_INSTR
" " F_HEX_4
" %s<id>%s" F_EOL
, prefix
, disk_blk, offset
, opcode
, uvalue
, VbufString( &fmt_prefix )
, VbufString( &fmt_suffix ) );
VbufFree( &fmt_prefix );
VbufFree( &fmt_suffix );
} break;
case DBG_OPCODE_NUL :
printf( F_NAME
" " F_BUF_FMT
" " F_INSTR F_EOL
, prefix
, disk_blk, offset
, opcode );
break;
case DBG_OPCODE_SRC :
{
printf( F_EOL F_NAME
" " F_BUF_FMT
" " F_INSTR
" " F_NAME F_EOL
, prefix
, disk_blk, offset
, opcode
, SrcFileFullName( ins->value.pvalue ) );
} break;
case DBG_OPCODE_SCP :
printf( F_NAME
" " F_BUF_FMT
" " F_INSTR
" " "scope: " F_HEX F_EOL
, prefix
, disk_blk, offset
, opcode
, uvalue );
break;
case DBG_OPCODE_STR :
case DBG_OPCODE_CON :
case DBG_OPCODE_BIN :
switch( ins->opcode ) {
case IC_OPR_BINARY :
case IC_OPR_UNARY :
printf( F_NAME
" " F_BUF_FMT
" " F_INSTR
" " F_NAME F_EOL
, prefix
, disk_blk, offset
, opcode
, DbgOperator( ins->value.uvalue ) );
break;
case IC_DBG_LINE :
printf( F_NAME
" " F_BUF_FMT
" " F_INSTR
" " F_DECIMAL F_EOL F_EOL
, prefix
, disk_blk, offset
, opcode
, uvalue );
break;
default :
printf( F_NAME
" " F_BUF_FMT
" " F_INSTR
" " F_HEX F_EOL
, prefix
, disk_blk, offset
, opcode
, uvalue );
break;
}
break;
default :
CFatal( "**** UNDEFINED OPCODE TYPE *****" );
break;
}
}
static void dumpPTreeNode( // DUMP A PARSE TREE NODE
PTREE node ) // - node in parse tree
{
static char buffer[128]; // - debugging buffer
char *node_name; // - name of node
VSTK_CTL ctl; // - VSTK control information (nodes)
VSTK_CTL dup; // - VSTK control information (duplicates)
int dup_out; // - last duplicate printed
VstkOpen( &ctl, sizeof( PTREE ), 32 );
VstkOpen( &dup, sizeof( PTREE ), 8 );
dup_out = -1;
for( ; ; ) {
switch( node->op ) {
case PT_ERROR :
printf( "PT_ERROR" F_BADDR
" ***** ERROR TREE *****" F_EOL
, node
);
break;
case PT_INT_CONSTANT :
node_name = "PT_INT_CONSTANT";
printf( F_NAME F_BADDR
" flags" F_HEX_4
" type" F_PTR
, node_name
, node
, node->flags
, node->type
);
if( NULL == Integral64Type( node->type ) ) {
printf( " integer" F_HEX_4
, node->u.int_constant
);
} else {
printf( " integer-64" F_S64
, VAL64( node->u.int64_constant )
);
}
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
break;
case PT_FLOATING_CONSTANT : {
char buffer[256];
BFCnvFS( node->u.floating_constant, buffer, 256 );
printf( "PT_FLOATING_CONSTANT" F_BADDR
" flags" F_HEX_4
" float" F_CPP_FLOAT
, node
, node->flags
, buffer
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
}
break;
case PT_STRING_CONSTANT :
stvcpy( buffer, node->u.string->string, node->u.string->len );
printf( "PT_STRING_CONSTANT" F_BADDR
" flags" F_HEX_4
" string" F_STRING
, node
, node->flags
, buffer
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
break;
case PT_ID :
printf( "PT_ID" F_BADDR
" flags" F_HEX_4
" cgop" F_STRING F_NL
" id" F_PTR
"=" F_STRING
" id_cgop" F_STRING
" u.id.scope" F_PTR
, node
, node->flags
, DbgOperator( node->cgop )
, node->u.id.name
, NameStr( node->u.id.name )
, DbgOperator( node->id_cgop )
, node->u.id.scope
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
break;
case PT_TYPE :
printf( "PT_TYPE" F_BADDR
" cgop" F_STRING
" flags" F_HEX_4
" next" F_PTR
" scope" F_PTR
, node
, DbgOperator( node->cgop )
, node->flags
, node->u.type.next
, node->u.type.scope
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
break;
case PT_SYMBOL :
if( node->cgop == CO_NAME_THIS ) {
printf( "PT_SYMBOL" F_BADDR
" flags" F_HEX_4
" this "
, node
, node->flags
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
} else if( node->cgop == CO_NAME_CDTOR_EXTRA ) {
printf( "PT_SYMBOL" F_BADDR
" flags" F_HEX_4
" cdtor_extra_parm "
, node
, node->flags
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
} else {
printf( "PT_SYMBOL" F_BADDR
" flags" F_HEX_4
" cgop" F_STRING F_NL
" symbol" F_PTR
" result" F_PTR
, node
, node->flags
, DbgOperator( node->cgop )
, node->u.symcg.symbol
, node->u.symcg.result
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
DumpSymbol( node->u.symcg.symbol );
}
break;
case PT_UNARY :
printf( "PT_UNARY" F_BADDR
F_POINTS F_ADDR
" flags" F_HEX_4
" cgop" F_STRING
, node
, node->u.subtree[0]
, node->flags
, DbgOperator( node->cgop )
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
PUSH_NODE( ctl, node->u.subtree[0] );
break;
case PT_BINARY :
printf( "PT_BINARY" F_BADDR
F_POINTS F_ADDR
"," F_ADDR
" flags" F_HEX_4
" cgop" F_STRING
, node
, node->u.subtree[0]
, node->u.subtree[1]
, node->flags
, DbgOperator( node->cgop )
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
PUSH_NODE( ctl, node->u.subtree[1] );
PUSH_NODE( ctl, node->u.subtree[0] );
break;
case PT_DUP_EXPR :
{ PTREE *duped; // - duplicated expression
printf( "PT_DUP_EXPR" F_BADDR
F_POINTS F_ADDR
" flags" F_HEX_4
" node" F_ADDR
, node
, node->u.dup.subtree[0]
, node->flags
, node->u.dup.node
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
if( node->u.subtree[0] != NULL ) {
for( duped = VstkTop( &dup )
;
; duped = VstkNext( &dup, duped ) ) {
if( duped == NULL ) {
PUSH_NODE( dup, node->u.subtree[0] );
} else if( *duped == node->u.subtree[0] ) {
break;
}
}
}
} break;
case PT_IC :
printf( "PT_IC" F_BADDR
" " F_NAME
" value" F_ADDR
, node
, DbgIcOpcode( node->u.ic.opcode )
, node->u.ic.value.pvalue
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
break;
default :
printf( "***INVALID***" F_BADDR
" flags" F_HEX_4
" op" F_HEX_1
, node
, node->flags
, node->op
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
break;
}
{
PTREE *next; // - addr[next node]
next = VstkPop( &ctl );
if( next != NULL ) {
node = *next;
} else {
++dup_out;
if( dup_out > VstkDimension( &dup ) ) break;
next = VstkIndex( &dup, dup_out );
printf( "--------------- duplicate ------------\n" );
node = *next;
}
}
}
VstkClose( &ctl );
VstkClose( &dup );
}
