PTREE ThrowTypeSig( // GET THROW ARGUMENT FOR TYPE SIGNATURE
TYPE type, // - type to be thrown
PTREE expr ) // - expression for errors
{
PTREE node; // - node constructed
type = TypeCanonicalThr( type );
if( throwCnvFront( type, expr ) ) {
node = NodeUnary( CO_TYPE_SIG, NULL );
node->type = type;
node = NodeArg( node );
node->type = type;
} else {
node = NULL;
}
return node;
}
// When bound, the function is called directly.
//
// When not bound,
// - fetch reference
// - add vf_offset
// - fetch VFT ptr
// - index using vf_index
//
static PTREE genVfunIcs( // GENERATE IC'S FOR CG-GENERATION OF VFUN CALL
target_offset_t vf_offset, // - offset to VF table ptr
PTREE node, // - original "this" expression
vindex vf_index, // - index into VF table
SYMBOL baser, // - basing "this" symbol
SYMBOL vfun ) // - virtual function
{
PTREE expr; // - expression under construction
expr = NodeMakeCallee( vfun );
expr->cgop = CO_IGNORE;
expr = NodeUnary( CO_CALL_SETUP_VFUN, expr );
expr->type = vfun->sym_type;
expr->flags = node->flags;
expr = PtdVfunAccess( expr, vf_index, vf_offset, baser );
node = NodeUnaryCopy( CO_VFUN_PTR, node );
return( NodeComma( node, expr ) );
}
void NodeConvertToBasePtr( // CONVERT TO A BASE PTR, USING SEARCH_RESULT
PTREE *a_expr, // - addr( ptr to be converted )
TYPE base, // - base type
SEARCH_RESULT *result, // - search result
bool positive ) // - true ==> use positive value
{
target_offset_t vb_offset; // - offset of vbptr
vindex vb_index; // - index in vbtable
target_offset_t delta; // - delta for class
PTREE node; // - new node
PTREE dup; // - node containing duplicate of original
PTREE orig; // - original value
TYPE ref_type; // - reference type for original value
node = *a_expr;
/* references can never be NULL by definition */
ref_type = TypeReference( NodeType( node ) );
if( ref_type != NULL ) {
node->flags |= PTF_PTR_NONZERO;
}
if( node->flags & PTF_MEMORY_EXACT ) {
adjust_by_delta( a_expr, base, result->exact_delta, positive );
} else if( result->non_virtual ) {
adjust_by_delta( a_expr, base, result->delta, positive );
} else {
PTF_FLAG orig_prop; // - flags propogated from original
SYMBOL ibp; // - inline bound reference parameter
target_offset_t offset; // - offset to ibp
#if 0
orig_prop = ( node->flags & PTF_FETCH ) | PTF_LVALUE;
#else
orig_prop = node->flags & PTF_FETCH;
if( NULL != ref_type ) {
orig_prop |= PTF_LVALUE;
}
#endif
if( NodeGetIbpSymbol( node, &ibp, &offset ) ) {
PTREE expr; // - expression under construction
unsigned vb_exact; // - exact offset for conversion
vb_exact = result->exact_delta;
if( ! positive ) {
vb_exact = - vb_exact;
}
vb_exact += offset;
if( NULL == ibp ) {
expr = NULL;
} else {
expr = NodeMakeCallee( ibp );
expr->cgop = CO_IGNORE;
}
expr = NodeUnary( CO_VBASE_FETCH, expr );
expr = PtdVbaseFetch( expr
, result->vb_offset
, result->vb_index
, result->delta + offset
, vb_exact );
expr->type = base;
expr->flags = orig_prop;
node = NodeReplace( node, expr );
} else {
dup = NULL;
if( ! NodePtrNonZero( node ) ) {
dup = NodeDupExpr( &node );
}
vb_offset = result->vb_offset;
vb_index = result->vb_index;
node = NodeConvertVirtualPtr( node, base, vb_offset, vb_index );
delta = result->delta;
if( delta != 0 ) {
node = NodeBinary( CO_DOT, node, NodeOffset( delta ) );
node->type = base;
node->flags |= orig_prop;
}
if( dup != NULL ) {
orig = NodeDupExpr( &dup );
node = NodeTestExpr( NodeCompareToZero( orig ), node, dup );
}
}
*a_expr = node;
}
if( ref_type != NULL ) {
(*a_expr)->flags |= PTF_LVALUE;
}
}
