void CpRemBlock( void )
{
sym_id rb;
if( EmptyCSList() == FALSE ) {
StmtErr( SP_BLK_IN_STRUCTURE );
}
AddCSNode( CS_REMOTEBLOCK );
CSHead->bottom = NextLabel();
CSHead->branch = NextLabel();
GBranch( CSHead->branch );
if( BlockName( SY_RB_DEFINED ) ) {
rb = CITNode->sym_ptr;
if( ( rb->ns.flags & SY_REFERENCED ) == 0 ) {
rb->ns.si.rb.ref_count = 0;
}
rb->ns.si.rb.ref_count++;
CSHead->cs_info.rb = rb;
GStartBlock();
BIStartRBorEP( rb );
}
AdvanceITPtr();
ReqEOS();
StNumbers.in_remote = TRUE;
ClearRem();
}
static void InitLoop( int loop_type )
{
AddCSNode( loop_type );
CSHead->branch = NextLabel();
CSHead->bottom = NextLabel();
CSHead->cycle = NextLabel();
GLabel( CSHead->branch );
}
static void ContinueStmt( void )
{
BLOCKPTR block;
int try_scope;
NextToken();
if( LoopStack != NULL ) {
if( ! DeadCode ) { /* 05-apr-92 */
try_scope = -2;
block = BlockStack;
while( block != LoopStack ) {
if( ( block->block_type == T__TRY )
|| ( block->block_type == T___TRY ) ) {
try_scope = block->parent_index;
}
block = block->prev_block;
}
if( try_scope != -2 ) {
UnWindTry( try_scope );
}
if( LoopStack->continue_label == 0 ) {
LoopStack->continue_label = NextLabel();
}
Jump( LoopStack->continue_label );
}
} else {
CErr1( ERR_MISPLACED_CONTINUE );
}
MustRecog( T_SEMI_COLON );
}
static void EndSwitch( void )
{
SWITCHPTR sw;
// CASEPTR ce;
sw = SwitchStack;
SwitchStack = sw->prev_switch;
if( sw->default_label == 0 ) {
if( BlockStack->break_label == 0 ) {
sw->default_label = NextLabel();
DropLabel( sw->default_label );
} else {
sw->default_label = BlockStack->break_label;
}
}
// if( sw->case_list == NULL ) {
// CWarn1( WARN_EMPTY_SWITCH, ERR_EMPTY_SWITCH );
// }
#if 0
for( ; ce = sw->case_list; ) {
sw->case_list = ce->next_case;
CMemFree( ce );
}
CMemFree( sw );
#endif
}
static bool BlockName( unsigned_16 rb_defined )
{
sym_id sym_ptr;
unsigned_16 flag_mask;
bool rb_name;
CSExtn();
rb_name = FALSE;
if( ReqName( NAME_REM_BLOCK ) ) {
sym_ptr = LkSym();
if( ( sym_ptr->ns.flags & ~SY_REFERENCED ) == 0 ) {
sym_ptr->ns.si.rb.entry = NextLabel();
sym_ptr->ns.flags = RB_FLAGS;
}
flag_mask = (unsigned_16)~( SY_RB_DEFINED | SY_REFERENCED );
if( ( ( sym_ptr->ns.flags & flag_mask ) == RB_FLAGS ) &&
( ( sym_ptr->ns.flags & rb_defined ) == 0 ) ) {
sym_ptr->ns.flags |= rb_defined;
rb_name = TRUE;
} else {
IllName( sym_ptr );
}
}
return( rb_name );
}
void CpElseIf(void) {
//==================
// Process an ELSEIF statement.
if( ( CSHead->typ == CS_IF ) || ( CSHead->typ == CS_ELSEIF ) ) {
GBranch( CSHead->bottom );
GLabel( CSHead->branch );
FreeLabel( CSHead->branch );
CSHead->typ = CS_ELSEIF;
CSHead->branch = NextLabel();
CSHead->block = ++BlockNum;
} else if( CSHead->typ == CS_ELSE ) {
Error( IF_ELSE_LAST );
} else {
Match();
}
CSCond( CSHead->branch );
if( RecKeyWord( "THEN" ) ) {
AdvanceITPtr();
ReqEOS();
} else {
Error( IF_NO_THEN );
}
}
sym_id STStmtNo( unsigned_32 stmnt_no ) {
//========================================
// Search the symbol table for a statement number. If it is not
// already in the symbol table, add it to the symbol table.
sym_id ste_ptr;
unsigned_32 st_number;
ste_ptr = SList;
while( ste_ptr != NULL ) {
st_number = GetStmtNum( ste_ptr );
if( st_number == stmnt_no ) {
return( ste_ptr );
}
ste_ptr = ste_ptr->u.st.link;
}
ste_ptr = FMemAlloc( sizeof( stmtno ) );
ste_ptr->u.st.block = CSHead->block;
ste_ptr->u.st.flags = SN_INIT;
if( stmnt_no > 65535 ) {
stmnt_no -= 65535;
ste_ptr->u.st.flags |= SN_ADD_65535;
}
ste_ptr->u.st.number = stmnt_no;
ste_ptr->u.st.address = NextLabel();
ste_ptr->u.st.ref_count = 0;
ste_ptr->u.st.link = SList;
SList = ste_ptr;
return( ste_ptr );
}
static void AddCaseLabel( unsigned long value )
{
CASEPTR ce, prev_ce, new_ce;
unsigned long old_value, converted_value;
TREEPTR tree;
char buffer[12];
prev_ce = NULL;
#if 0
leaf.u.ulong_konst = value;
leaf.data_type = SwitchStack->case_type;
SetLeafType( &leaf, 1 );
// converted_value = value & SwitchStack->case_mask;
converted_value = leaf.u.ulong_konst;
#else
converted_value = value;
#endif
old_value = converted_value + 1; /* make old_value different */
for( ce = SwitchStack->case_list; ce; ce = ce->next_case ) {
old_value = ce->value;
if( old_value >= converted_value ) break;
prev_ce = ce;
}
if( converted_value == old_value ) { /* duplicate case value found */
sprintf( buffer, SwitchStack->case_format, value );
CErr2p( ERR_DUPLICATE_CASE_VALUE, buffer );
} else {
new_ce = (CASEPTR)CMemAlloc( sizeof( CASEDEFN ) );
new_ce->value = converted_value;
if( prev_ce == NULL ) {
new_ce->next_case = SwitchStack->case_list;
SwitchStack->case_list = new_ce;
} else {
prev_ce->next_case = new_ce;
new_ce->next_case = ce;
}
/* Check if the previous statement was a 'case'. If so, reuse the label, as generating
* too many labels seriously slows down code generation.
*/
if( prev_ce && LastStmt->op.opr == OPR_STMT && LastStmt->right->op.opr == OPR_CASE ) {
new_ce->label = SwitchStack->last_case_label;
new_ce->gen_label = FALSE;
} else {
new_ce->label = NextLabel();
new_ce->gen_label = TRUE;
}
SwitchStack->number_of_cases++;
if( converted_value < SwitchStack->low_value ) {
SwitchStack->low_value = converted_value;
}
if( converted_value > SwitchStack->high_value ) {
SwitchStack->high_value = converted_value;
}
SwitchStack->last_case_label = new_ce->label;
tree = LeafNode( OPR_CASE );
tree->op.case_info = new_ce;
AddStmt( tree );
}
}
static void NewLoop( void )
{
StartNewBlock();
LoopStack = BlockStack;
LoopStack->top_label = NextLabel();
DropLabel( LoopStack->top_label );
++LoopDepth;
}
static int EndTry( void )
{
int parent_scope;
TREEPTR expr;
TREEPTR func;
TREEPTR tree;
TYPEPTR typ;
int expr_type;
DropBreakLabel(); /* _leave jumps to this label */
parent_scope = BlockStack->parent_index;
tree = LeafNode( OPR_TRY );
tree->op.st.try_index = BlockStack->try_index;
tree->op.st.parent_scope = parent_scope;
AddStmt( tree );
if( (CurToken == T__EXCEPT) || (CurToken == T___EXCEPT) ) {
NextToken();
BlockStack->block_type = T__EXCEPT;
BlockStack->break_label = NextLabel();
Jump( BlockStack->break_label );
DeadCode = 0;
tree = LeafNode( OPR_EXCEPT );
tree->op.st.try_sym_handle = DummyTrySymbol();
tree->op.st.parent_scope = parent_scope;
AddStmt( tree );
CompFlags.exception_filter_expr = 1;
expr = RValue( BracketExpr() );
CompFlags.exception_filter_expr = 0;
CompFlags.exception_handler = 1;
typ = TypeOf( expr );
expr_type = DataTypeOf( typ );
if( expr_type != TYPE_VOID ) {
if( expr_type > TYPE_ULONG ) {
CErr1( ERR_EXPR_MUST_BE_INTEGRAL );
}
}
func = VarLeaf( SymGetPtr( SymExcept ), SymExcept );
func->op.opr = OPR_FUNCNAME;
expr = ExprNode( NULL, OPR_PARM, expr );
expr->expr_type = typ;
expr->op.result_type = typ;
tree = ExprNode( func, OPR_CALL, expr );
tree->expr_type = GetType( TYPE_VOID );
AddStmt( tree );
return( 1 );
} else if( (CurToken == T__FINALLY) || (CurToken == T___FINALLY) ) {
CompFlags.in_finally_block = 1;
NextToken();
BlockStack->block_type = T__FINALLY;
DeadCode = 0;
tree = LeafNode( OPR_FINALLY );
tree->op.st.try_sym_handle = DummyTrySymbol();
tree->op.st.parent_scope = parent_scope;
AddStmt( tree );
return( 1 );
}
return( 0 );
}
static void JumpBreak( BLOCKPTR block )
{
if( !DeadCode ) { /* 05-apr-92 */
if( block->break_label == 0 ) {
block->break_label = NextLabel();
}
Jump( block->break_label );
}
}
void GGotoEpilog( void ) {
//=====================
// Generate a branch to the epilogue.
if( EpilogLabel == 0 ) {
EpilogLabel = NextLabel();
}
GBranch( EpilogLabel );
}
void InitDo( signed_32 term )
{
// Initialize a DO or implied DO.
// Process "do i=e1,e2,e3" where e1, e2 and e3 are numeric expressions.
//
do_entry *do_pointer;
sym_id do_var;
if( ( StmtSw & SS_DATA_INIT ) == 0 ) {
CSHead->branch = NextLabel();
CSHead->bottom = NextLabel();
CSHead->cycle = NextLabel();
}
do_pointer = FMemAlloc( sizeof( do_entry ) );
CSHead->cs_info.do_parms = do_pointer;
do_pointer->do_term = term;
do_pointer->do_parm = NULL;
if( ReqDoVar() ) {
CkTypeDeclared();
do_var = CITNode->sym_ptr;
BIOutSymbol( do_var );
do_var->u.ns.flags |= SY_REFERENCED;
do_var->u.ns.u1.s.xflags |= SY_DEFINED;
if( do_var->u.ns.flags & SY_DO_PARM ) {
Error( DO_PARM_REDEFINED );
}
do_pointer->do_parm = do_var; // remember id of "i"
ReqNextOpr( OPR_EQU, EQ_NO_EQUALS );
if( StmtSw & SS_DATA_INIT ) {
if( !_IsTypeInteger( do_var->u.ns.u1.s.typ ) ) {
NameErr( DA_BAD_DO_VAR, do_var );
}
do_var = STShadow( do_var );
CITNode->flags = do_var->u.ns.flags;
}
CITNode->sym_ptr = do_var;
GDoInit( do_var->u.ns.u1.s.typ );
do_var->u.ns.flags |= SY_DO_PARM;
}
}
void FormatIdd( void ) {
//=========================
cs_label fmt_label;
grp_entry *ge;
if( RecName() && ( NameListFind() != NULL ) ) {
BIOutNameList( CITNode->sym_ptr );
ge = CITNode->sym_ptr->u.nl.group_list;
while( ge != NULL ) {
ge->sym->u.ns.flags |= SY_REFERENCED;
ge = ge->link;
}
GSetNameList( FC_SET_NML );
KWRememb( IO_NAMELIST );
} else if( RecNumber() ) {
GPassStmtNo( LkUpFormat(), FC_SET_FMT );
} else if( RecNOpn() && RecNextOpr( OPR_MUL ) ) {
if( CITNode->link->opn.ds == DSOPN_PHI ) {
AdvanceITPtr(); // nothing needs to be loaded for default
KWRememb( IO_LIST_DIR );
}
} else if( RecNOpn() && RecNextOpr( OPR_COM ) ) {
Extension( IL_NO_ASTERISK );
} else if( RecIntVar() ) {
CkVarRef();
StNumbers.var_format = true;
GFmtVarSet();
} else {
ProcIOExpr(); // will allow for array name alone
if( !AError ) {
if( RecArrName() ) {
if( CITNode->typ != FT_CHAR ) {
Extension( IL_NON_CHARACTER );
}
ChkAssumed();
GFmtArrSet();
} else if( CITNode->typ != FT_CHAR ) {
Error( IL_BAD_FMT_SPEC );
} else if( ( CITNode->opn.us == USOPN_CON ) ) {
AddConst( CITNode ); // in case single constant
fmt_label.g_label = NextLabel();
FScan( CITNode->sym_ptr->u.lt.length,
(char *)&CITNode->sym_ptr->u.lt.value, fmt_label );
GPassLabel( fmt_label.g_label, RT_SET_FMT );
} else {
GFmtExprSet();
}
}
}
}
void CpLogIf(void) {
//=================
// Process a logical IF statement.
label_id if_skip;
if_skip = NextLabel();
CSCond( if_skip );
if( RecKeyWord( "THEN" ) &&
( RecNextOpr( OPR_TRM ) || RecNextOpr( OPR_COL ) ) ) {
AddCSNode( CS_IF );
CSHead->branch = if_skip;
CSHead->bottom = NextLabel();
CITNode->opn.ds = DSOPN_PHI; // not part of the block label
BlockLabel();
CtrlFlgs |= CF_BAD_DO_ENDING;
} else {
Recurse();
GLabel( if_skip );
FreeLabel( if_skip );
}
}
static void ElseStmt( void )
{
LABEL_INDEX if_label;
SrcLoc = TokenLoc;
NextToken();
BlockStack->block_type = T_ELSE;
if_label = BlockStack->break_label;
if( DeadCode ) { /* 05-apr-92 */
BlockStack->break_label = 0;
} else {
BlockStack->break_label = NextLabel();
Jump( BlockStack->break_label );
}
DropLabel( if_label );
}
static void ForStmt( void )
{
bool parsed_semi_colon = FALSE;
NextToken();
MustRecog( T_LEFT_PAREN );
if( CompFlags.c99_extensions ) {
PushBlock(); // 'for' opens new scope
}
if( CurToken != T_SEMI_COLON ) {
if( CompFlags.c99_extensions ) {
TREEPTR tree;
tree = LeafNode( OPR_NEWBLOCK );
AddStmt( tree );
BlockStack->gen_endblock = TRUE;
if( !LoopDecl( &BlockStack->sym_list ) ) {
ChkStmtExpr(); // no declarator, try init_expr
} else {
parsed_semi_colon = TRUE; // LoopDecl ate it up
}
tree->op.sym_handle = BlockStack->sym_list;
} else {
ChkStmtExpr(); // init_expr
}
}
if( !parsed_semi_colon ) {
MustRecog( T_SEMI_COLON );
}
NewLoop();
BlockStack->block_type = T_FOR;
if( CurToken != T_SEMI_COLON ) {
BlockStack->break_label = NextLabel();
if( !JumpFalse( Expr(), BlockStack->break_label ) ) {
BlockStack->break_label = 0; /* 09-sep-92 */
}
}
MustRecog( T_SEMI_COLON );
BlockStack->inc_var = NULL;
if( CurToken != T_RIGHT_PAREN ) {
BlockStack->inc_var = Expr(); // save this
if( CompFlags.meaningless_stmt == 1 ) {
ChkUseful();
}
}
MustRecog( T_RIGHT_PAREN );
}
static void DefaultStmt( void )
{
NextToken();
MustRecog( T_COLON );
if( SwitchStack ) {
if( SwitchStack->default_label == 0 ) {
SwitchStack->default_label = NextLabel();
DropLabel( SwitchStack->default_label );
} else {
CErr1( ERR_ONLY_1_DEFAULT );
}
if( CurToken == T_RIGHT_BRACE ) {
CErr1( ERR_STMT_REQUIRED_AFTER_DEFAULT );
}
} else {
CErr1( ERR_MISPLACED_DEFAULT );
}
}
void GEPProlog( void ) {
//===================
// Generate an entry point prologue.
sym_id ep;
char *ptr;
char name[MAX_SYMLEN+3];
ep = ArgList->id;
ep->u.ns.si.sp.u.entry = NextLabel();
GLabel( ep->u.ns.si.sp.u.entry );
// by the time we define the label for the entry point, the code that
// references it will have been executed
FreeLabel( ep->u.ns.si.sp.u.entry );
SetArgAddrs();
if( CommonEntry == NULL ) {
ptr = name;
*ptr = '$';
ptr++;
ptr = STGetName( SubProgId, ptr );
*ptr = '.';
ptr++;
*ptr = NULLCHAR;
CommonEntry = SymLookup( name, SubProgId->u.ns.u2.name_len + 2 );
if( (SubProgId->u.ns.flags & SY_SUBPROG_TYPE) == SY_SUBROUTINE ) {
CommonEntry->u.ns.flags = SY_USAGE | SY_SUBPROGRAM | SY_SUBROUTINE |
SY_SENTRY | SY_REFERENCED;
} else {
CommonEntry->u.ns.flags = SY_USAGE | SY_SUBPROGRAM | SY_FUNCTION |
SY_SENTRY | SY_REFERENCED;
}
EPValue = SymLookup( "$@EVAL", 6 );
EPValue->u.ns.flags |= SY_REFERENCED;
EPValue->u.ns.u1.s.xflags |= SY_DEFINED;
}
}
void Statement( void )
{
LABEL_INDEX end_of_func_label;
SYM_HANDLE func_result;
TREEPTR tree;
bool return_at_outer_level;
bool skip_to_next_token;
bool declaration_allowed;
struct return_info return_info;
SYM_ENTRY sym;
#ifndef NDEBUG
if( DebugFlag >= 1 ) {
printf( "***** line %u, func=%s\n", TokenLoc.line, CurFunc->name );
PrintStats();
}
#endif
++FuncCount;
return_info.with = RETURN_WITH_NONE; /* indicate no return statements */
return_info.with_expr = FALSE;
CompFlags.label_dropped = 0;
CompFlags.addr_of_auto_taken = 0; /* 23-oct-91 */
end_of_func_label = 0;
return_at_outer_level = FALSE; /* 28-feb-92 */
declaration_allowed = FALSE;
DeadCode = 0;
LoopDepth = 0;
LabelIndex = 0;
BlockStack = NULL;
LoopStack = NULL;
SwitchStack = NULL;
#ifdef __SEH__
TryCount = -1;
TryScope = -1;
#endif
StartNewBlock();
NextToken(); // skip over {
++SymLevel;
tree = LeafNode( OPR_LABELCOUNT );
AddStmt( tree );
if( GrabLabels() == 0 ) { /* 29-nov-94 */
GetLocalVarDecls();
}
func_result = MakeNewSym( &sym, 'R', CurFunc->sym_type->object, SC_AUTO );
sym.flags |= SYM_FUNC_RETURN_VAR; /* 25-oct-91 */
SymReplace( &sym, func_result );
for( ;; ) {
CompFlags.pending_dead_code = 0;
if( GrabLabels() == 0 && declaration_allowed && IsDeclarator( CurToken ) ) {
GetLocalVarDecls();
}
if( CompFlags.c99_extensions ) {
declaration_allowed = TRUE;
}
skip_to_next_token = FALSE;
switch( CurToken ) {
case T_IF:
StartNewBlock();
NextToken();
BlockStack->break_label = NextLabel();
JumpFalse( BracketExpr(), BlockStack->break_label );
/* 23-dec-88, only issue msg if ';' is on same line as 'if' */
if( CurToken == T_SEMI_COLON && SrcLoc.line == TokenLoc.line && SrcLoc.fno == TokenLoc.fno ) {
SetErrLoc( &TokenLoc );
NextToken(); /* look ahead for else keyword */
if( CurToken != T_ELSE ) { /* 02-apr-91 */
ChkUseful(); /* 08-dec-88 */
}
InitErrLoc();
break;
}
declaration_allowed = FALSE;
continue;
case T_WHILE:
NewLoop();
NextToken();
BlockStack->break_label = NextLabel();
if( !JumpFalse( BracketExpr(), BlockStack->break_label ) ) {
BlockStack->break_label = 0; /* 09-sep-92 */
}
if( CurToken == T_SEMI_COLON ) { /* 08-dec-88 */
if( ! CompFlags.useful_side_effect ) {
CWarn1( WARN_MEANINGLESS, ERR_MEANINGLESS );
}
}
declaration_allowed = FALSE;
continue;
case T_DO:
NewLoop();
NextToken();
if( CurToken == T_RIGHT_BRACE ) {
CErr1( ERR_STMT_REQUIRED_AFTER_DO );
break;
}
declaration_allowed = FALSE;
continue;
case T_FOR:
ForStmt();
declaration_allowed = FALSE;
continue;
case T_SWITCH:
SwitchStmt();
DeadCode = 1;
declaration_allowed = FALSE;
continue;
case T_CASE:
DeadCode = 0;
CaseStmt();
declaration_allowed = FALSE;
continue;
case T_DEFAULT:
DefaultStmt();
declaration_allowed = FALSE;
continue;
case T_BREAK:
BreakStmt();
DeadCode = 1;
if( BlockStack->block_type != T_LEFT_BRACE ) break;
continue;
case T_CONTINUE:
ContinueStmt();
DeadCode = 1;
if( BlockStack->block_type != T_LEFT_BRACE ) break;
continue;
#ifdef __SEH__
case T__LEAVE:
case T___LEAVE:
LeaveStmt();
DeadCode = 1;
if( BlockStack->block_type != T_LEFT_BRACE ) break;
continue;
#endif
case T_RETURN:
ReturnStmt( func_result, &return_info );
if( BlockStack->prev_block == NULL ) { /* 28-feb-92 */
return_at_outer_level = TRUE;
}
MustRecog( T_SEMI_COLON );
if( SymLevel != 1 || CurToken != T_RIGHT_BRACE ||
BlockStack->block_type != T_LEFT_BRACE ) {
if( end_of_func_label == 0 ) {
end_of_func_label = NextLabel();
}
Jump( end_of_func_label );
}
if( BlockStack->block_type != T_LEFT_BRACE ) break;
continue;
case T_GOTO:
GotoStmt();
if( BlockStack->block_type != T_LEFT_BRACE ) break;
continue;
case T_SEMI_COLON:
NextToken();
if( BlockStack->block_type != T_LEFT_BRACE ) {
if( CurToken == T_ELSE ) {
declaration_allowed = FALSE;
}
break;
}
continue;
case T_LEFT_BRACE:
LeftBrace();
continue;
case T_RIGHT_BRACE:
if( BlockStack->block_type != T_LEFT_BRACE ) {
CErr1( ERR_MISPLACED_RIGHT_BRACE );
}
if( BlockStack->prev_block == NULL ) {
skip_to_next_token = TRUE;
} else {
NextToken();
}
break;
case T_EXTERN:
case T_STATIC:
case T_AUTO:
case T_REGISTER:
case T_VOID:
case T_CHAR:
case T_SHORT:
case T_INT:
case T_LONG:
case T_FLOAT:
case T_DOUBLE:
case T_SIGNED:
case T_UNSIGNED:
if( CompFlags.c99_extensions )
CErr1( ERR_UNEXPECTED_DECLARATION );
else
CErr1( ERR_MISSING_RIGHT_BRACE );
break;
case T_EOF:
CErr1( ERR_MISSING_RIGHT_BRACE );
break;
#ifdef __SEH__
case T__TRY:
case T___TRY:
TryStmt();
continue;
#endif
case T___ASM:
AsmStmt();
continue;
default:
if( DeadCode == 1 ) {
DeadMsg();
}
StmtExpr();
if( BlockStack->block_type != T_LEFT_BRACE ) break;
continue;
}
EndOfStmt();
if( BlockStack == NULL ) break;
if( skip_to_next_token ) {
NextToken();
}
}
/* C99 has special semantics for return value of main() */
if( CompFlags.c99_extensions && !strcmp( CurFunc->name, "main" ) ) {
if( !return_at_outer_level ) {
FixupC99MainReturn( func_result, &return_info );
return_at_outer_level = TRUE;
}
}
if( !return_info.with_expr ) { /* no return values present */
if( !DeadCode && !CurFunc->naked ) {
ChkRetValue();
}
} else if( ! return_at_outer_level ) { /* 28-feb-92 */
if( ! DeadCode && !CurFunc->naked ) {
CWarn( WARN_MISSING_RETURN_VALUE,
ERR_MISSING_RETURN_VALUE, CurFunc->name );
}
}
if( end_of_func_label != 0 ) {
DropLabel( end_of_func_label );
}
DeadCode = 0;
tree->op.label_count = LabelIndex;
tree = LeafNode( OPR_FUNCEND );
if( !return_info.with_expr ) {
tree->expr_type = NULL;
tree->op.sym_handle = 0;
} else {
tree->op.sym_handle = func_result;
SetFuncReturnNode( tree );
}
AddStmt( tree );
AddSymList( CurFunc->u.func.locals );
SrcLoc = TokenLoc;
FreeLabels();
if( skip_to_next_token ) {
NextToken();
}
if( CompFlags.generate_prototypes ) {
if( DefFile == NULL ) {
OpenDefFile();
}
if( DefFile != NULL && CurFunc->stg_class == SC_NULL ) {
/* function exported */
DumpFuncDefn();
}
}
if( Toggles & TOGGLE_INLINE ) {
if( Inline_Threshold < NodeCount ) {
CurFuncNode->op.func.flags &= ~FUNC_OK_TO_INLINE;
}
}
if( VarParm( CurFunc ) ) {
CurFuncNode->op.func.flags &= ~FUNC_OK_TO_INLINE;
}
NodeCount = 0;
if( CompFlags.addr_of_auto_taken ) { /* 23-oct-91 */
CurFunc->flags &= ~ SYM_OK_TO_RECURSE;
}
}
