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 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 );
}
}
// #pragma inline_depth n
// #pragma inline_depth( n ) -- MS compatible
//
// Used to set the depth, up to which, inlining of functions will take place.
// "n" must be number 0:255
//
static void pragInlineDepth( // PROCESS #pragma inline_depth
void )
{
unsigned num;
if( grabNum( &num ) && num <= MAX_INLINE_DEPTH ) {
CgBackSetInlineDepth( num );
} else {
CErr1( ERR_PRAG_INLINE_DEPTH );
}
}
// #pragma template_depth n
// #pragma template_depth( n )
//
// Used to set the depth, up to which, function templates will be expanded
static void pragTemplateDepth( // PROCESS #pragma template_depth
void )
{
unsigned num;
if( grabNum( &num ) ) {
TemplateSetDepth( num );
} else {
CErr1( ERR_PRAG_TEMPLATE_DEPTH );
}
}
// forms: #pragma initialize [before/after]* priority
//
// where priority is:
// - number 0 - 255
// - library (32)
// - program (64)
//
// The pragma is used to set the initialize priority for the module ( when
// it occurs at file scope) or to specify an initialization function to
// be called (when it occurs within a function).
//
// The function must be previously declared to have no parameters and to
// be static.
//
static void pragInitialize( // #pragma initialize ...
void )
{
int adjust; // - before/after adjustment
unsigned priority; // - initialization priority
unsigned test;
adjust = 0;
for( ; ; ) {
/* allow "before before library" */
if( PragRecog( "after" ) ) {
++adjust;
} else if( PragRecog( "before" ) ) {
--adjust;
} else {
break;
}
}
priority = INIT_PRIORITY_PROGRAM;
if( CurToken == T_CONSTANT ) {
test = U32Fetch( Constant64 );
if( test <= 255 ) {
priority = test;
} else {
CErr1( ERR_PRAG_INITIALIZE_PRIORITY );
}
} else if( PragRecog( "library" ) ) {
priority = INIT_PRIORITY_LIBRARY;
} else if( PragRecog( "program" ) ) {
priority = INIT_PRIORITY_PROGRAM;
} else {
CErr1( ERR_PRAG_INITIALIZE_PRIORITY );
}
NextToken();
priority += adjust;
if( priority > 255 ) {
CErr1( ERR_PRAG_INITIALIZE_PRIORITY );
priority = INIT_PRIORITY_PROGRAM;
}
CompInfo.init_priority = priority;
}
static void defineFSRegistration( void )
{
if( CompFlags.zo_switch_used ) {
CErr1( WARN_ZO_OBSOLETE );
}
CompFlags.rw_registration = TRUE;
#if _CPU == 386
if( TargetSystem == TS_NT || TargetSystem == TS_OS2 ) {
CompFlags.fs_registration = TRUE;
}
#endif
}
void CppStackFini( void )
{
struct cpp_info *cpp;
while( (cpp = CppStack) != NULL ) {
SetErrLoc( &cpp->src_loc );
CErr1( ERR_MISSING_CENDIF );
InitErrLoc();
CppStack = cpp->prev_cpp;
CMemFree( cpp );
}
CppStack = NULL;
}
bool TypeDefedNonAbstract // REQUIRE DEFINED, NON-ABSTRACT TYPE
( TYPE type // - the type
, PTREE expr // - NULL or expression for error
, MSG_NUM msg_abstract // - message when abstract
, MSG_NUM msg_undefed ) // - message when undefined
{
bool retb; // - return: true ==> defined & non-abstract
expr = expr;
retb = false;
if( ! TypeDefined( type ) ) {
CErr1( msg_undefed );
InfClassDecl( type );
} else if( AbstractClassType( type ) ) {
CErr1( msg_abstract );
InfClassDecl( type );
ScopeNotePureFunctions( type );
} else {
retb = true;
}
return( retb );
}
void SetFarHuge( SYMPTR sym, bool report )
{
TYPEPTR typ;
type_modifiers attrib;
target_size size;
#if _CPU != 8086
/* unused parameters */ (void)report;
#endif
#if _CPU == 8086
if( sym->attribs.declspec == DECLSPEC_DLLIMPORT
|| sym->attribs.declspec == DECLSPEC_DLLEXPORT ) {
sym->mods |= FLAG_FAR;
} else if( sym->mods & FLAG_EXPORT ) {
sym->mods |= FLAG_FAR;
}
#endif
size = SizeOfArg( sym->sym_type );
if( TargetSwitches & BIG_DATA ) {
attrib = sym->mods;
if( (attrib & MASK_ALL_MEM_MODELS) == 0 ) {
if( size == 0 ) { /* unspecified array size */
if( sym->attribs.stg_class == SC_EXTERN ) {
typ = sym->sym_type;
if( typ->decl_type == TYPE_ARRAY ) {
attrib |= FLAG_FAR;
}
}
} else if( size > DataThreshold ) {
attrib |= FLAG_FAR;
} else if( CompFlags.strings_in_code_segment && ( sym->mods & FLAG_CONST ) ) {
attrib |= FLAG_FAR;
}
#if _CPU == 8086
if( (attrib & FLAG_FAR) && size > 0x10000 ) {
attrib &= ~FLAG_FAR;
attrib |= FLAG_HUGE;
}
#endif
sym->mods = attrib;
}
}
#if _CPU == 8086
if( report && size > 0x10000 && (sym->mods & FLAG_HUGE) == 0 ) {
SetErrLoc( &sym->src_loc );
CErr1( ERR_VAR_TOO_LARGE );
InitErrLoc();
}
#endif
}
static void SwitchStmt( void )
{
SWITCHPTR sw;
TREEPTR tree;
TYPEPTR typ;
int switch_type;
StartNewBlock();
NextToken();
sw = (SWITCHPTR)CMemAlloc( sizeof( SWITCHDEFN ) );
sw->prev_switch = SwitchStack;
sw->low_value = ~0l;
sw->high_value = 0;
sw->case_format = "%ld"; /* assume signed cases */
SwitchStack = sw;
switch_type = TYPE_INT; /* assume int */
tree = RValue( BracketExpr() );
typ = TypeOf( tree );
if( typ->decl_type == TYPE_ENUM ) typ = typ->object;
if( typ->decl_type == TYPE_UFIELD ) {
if( typ->u.f.field_width == (TARGET_INT * 8) ) {
sw->case_format = "%lu";
switch_type = TYPE_UINT;
}
}
switch( typ->decl_type ) {
case TYPE_USHORT:
case TYPE_UINT:
sw->case_format = "%lu";
switch_type = TYPE_UINT;
case TYPE_CHAR:
case TYPE_UCHAR:
case TYPE_SHORT:
case TYPE_INT:
case TYPE_FIELD:
case TYPE_UFIELD:
break;
case TYPE_ULONG:
sw->case_format = "%lu";
switch_type = TYPE_ULONG;
break;
case TYPE_LONG:
switch_type = TYPE_LONG;
break;
default:
CErr1( ERR_INVALID_TYPE_FOR_SWITCH );
}
tree = ExprNode( 0, OPR_SWITCH, tree );
tree->op.switch_info = sw;
AddStmt( tree );
}
static void pchWarn( MSG_NUM msg )
{
if( CompFlags.no_pch_warnings ) {
return;
}
if( CompFlags.fhr_switch_used ) {
return;
}
if( CompFlags.fhwe_switch_used ) {
CWarnDontCount( msg );
} else {
CErr1( msg );
}
}
static void macroAllocSegment( // ALLOCATE MACRO SEGMENT
unsigned minimum ) // - minimum size req'd
{
MACRO_SEG_LIST *macroSegment;
if( minimum > MAC_SEGMENT_LIMIT ) {
CErr1( ERR_OUT_OF_MACRO_MEMORY );
CSuicide();
}
macroSegment = RingAlloc( ¯oSegmentList, sizeof( MACRO_SEG_LIST ) );
MacroOffset = macroSegment->segment;
macroSegmentLimit = MAC_SEGMENT_LIMIT;
ExtraRptIncrementCtr( macro_segments );
}
void SetFarHuge( SYMPTR sym, int report )
{
TYPEPTR typ;
type_modifiers attrib;
unsigned long size;
report = report; /* in case not used */
#if _CPU == 8086
if( sym->declspec == DECLSPEC_DLLIMPORT
|| sym->declspec == DECLSPEC_DLLEXPORT ) { /* 16-dec-94 */
sym->attrib |= FLAG_FAR;
} else if( sym->attrib & FLAG_EXPORT ) {
sym->attrib |= FLAG_FAR;
}
#endif
size = SizeOfArg( sym->sym_type );
if( TargetSwitches & BIG_DATA ) {
attrib = sym->attrib;
if( (attrib & MASK_ALL_MEM_MODELS) == 0 ) {
if( size == 0 ) { /* unspecified array size */
if( sym->stg_class == SC_EXTERN ) {
typ = sym->sym_type;
if( typ->decl_type == TYPE_ARRAY ) {
attrib |= FLAG_FAR;
}
}
} else if( size > DataThreshold ) {
attrib |= FLAG_FAR;
} else if( CompFlags.strings_in_code_segment
&& ( sym->attrib & FLAG_CONST ) ) {
attrib |= FLAG_FAR;
}
#if _CPU == 8086
if( (attrib & FLAG_FAR) && size > 0x10000 ) {
attrib &= ~FLAG_FAR;
attrib |= FLAG_HUGE;
}
#endif
sym->attrib = attrib;
}
}
#if _CPU == 8086
if( report && size > 0x10000 && !(sym->attrib & FLAG_HUGE) ) {
SetErrLoc( &sym->src_loc );
CErr1( ERR_VAR_TOO_LARGE );
InitErrLoc();
}
#endif
}
static void GotoStmt( void )
{
LABELPTR label;
NextToken();
if( CurToken != T_ID ) {
CErr1( ERR_EXPECTING_LABEL );
} else {
label = LkLabel( Buffer );
label->referenced = 1; /* 05-apr-91 */
Jump( label->ref_list );
}
NextToken();
MustRecog( T_SEMI_COLON );
}
static void CaseStmt( void )
{
const_val val;
NextToken();
if( SwitchStack ) {
if( ConstExprAndType( &val ) ) {
if( ( val.type == TYPE_ULONG64 ) && !U64IsU32( val.value ) ) {
CErr1( ERR_CONSTANT_TOO_BIG );
} else if( ( val.type == TYPE_LONG64 ) && !I64IsI32( val.value ) ) {
CErr1( ERR_CONSTANT_TOO_BIG );
}
AddCaseLabel( U32FetchTrunc( val.value) );
}
MustRecog( T_COLON );
if( CurToken == T_RIGHT_BRACE ) {
CErr1( ERR_STMT_REQUIRED_AFTER_CASE );
}
} else {
CErr1( ERR_MISPLACED_CASE );
ConstExprAndType( &val ); /* grab constant expression */
MustRecog( T_COLON );
}
}
static void idiv64 // DO 64-BIT SIGNED DIVISION
( signed_64 const * v1 // - top
, signed_64 const * v2 // - divisor
, signed_64* result // - result
, signed_64* rem ) // - remainder
{
if( v2->u._32[0] == 0
&& v2->u._32[1] == 0 ) {
CErr1( ERR_DIVISION_BY_ZERO );
result->u._32[ I64HI32 ] = 0;
result->u._32[ I64LO32 ] = 1;
rem->u._32[ I64HI32 ] = 0;
rem->u._32[ I64LO32 ] = 0;
} else {
I64Div( v1, v2, result, rem );
}
}
void AsmStmt( void )
/******************/
{
int too_many_bytes;
unsigned char buff[ MAXIMUM_BYTESEQ + 32 ];
TOKEN skip_token;
ppctl_t old_ppctl;
old_ppctl = CompFlags.pre_processing;
// indicate that we are inside an __asm statement so scanner will
// allow tokens unique to the assembler. e.g. 21h
PPCTL_ENABLE_ASM();
NextToken();
AsmSysInit( buff );
too_many_bytes = 0;
if( CurToken == T_LEFT_BRACE ) {
NextToken();
for( ;; ) { // grab assembler lines
GetAsmLine();
if( AsmCodeAddress > MAXIMUM_BYTESEQ ) {
if( ! too_many_bytes ) {
CErr1( ERR_TOO_MANY_BYTES_IN_PRAGMA );
too_many_bytes = 1;
}
// reset index to we don't overrun buffer
AsmCodeAddress = 0;
}
if( CurToken == T_RIGHT_BRACE )
break;
if( CurToken == T_EOF )
break;
NextToken();
}
skip_token = T_RIGHT_BRACE;
} else {
GetAsmLine(); // grab single assembler instruction
skip_token = T_NULL;
}
CompFlags.pre_processing = old_ppctl;
AsmSysMakeInlineAsmFunc( too_many_bytes );
AsmSysFini();
if( CurToken == skip_token ) {
NextToken();
}
}
static void LeaveStmt( void )
{
BLOCKPTR block;
NextToken();
block = BlockStack;
while( block != NULL ) {
if( (block->block_type == T__TRY) || (block->block_type == T___TRY) )
break;
block = block->prev_block;
}
if( block != NULL ) {
JumpBreak( block );
} else {
CErr1( ERR_MISPLACED_LEAVE );
}
MustRecog( T_SEMI_COLON );
}
local void InitWCharArray( TYPEPTR typ )
{
unsigned len;
unsigned i;
STRING_LITERAL *str_lit;
unsigned value;
unsigned short *pwc;
unsigned long size;
DATA_QUAD dq;
dq.type = QDT_SHORT;
dq.flags = Q_DATA;
/* This function handles the initialization of statements like: */
/* wchar_t name[5] = L"abcd"; */
str_lit = GetLiteral();
if( !CompFlags.wide_char_string )
CErr1( ERR_TYPE_MISMATCH );
len = str_lit->length / sizeof(unsigned short);
if( typ->u.array->unspecified_dim ) {
typ->u.array->dimension = len;
}
size = typ->u.array->dimension;
if( len > size ) {
if( (len - size) > 1 ) {
CWarn1( WARN_LIT_TOO_LONG, ERR_LIT_TOO_LONG );
}
len = size;
}
pwc = (unsigned short *)str_lit->literal;
i = 0;
while( i < len ) {
value = *pwc++;
if( value != 0 ) CompFlags.non_zero_data = 1;
dq.u.long_values[0] = value;
GenDataQuad( &dq, sizeof( target_short ) );
++i;
}
if( i < size ) {
ZeroBytes( (size - i) * sizeof(unsigned short) );
}
FreeLiteral( str_lit );
}
static void scanInputFile( // PROCESS NAME OF INPUT FILE
void )
{
char filename[ _MAX_PATH ]; // - scanned file name
size_t len; // - length of file name
char const *fnm; // - file name in command line
len = CmdScanFilename( &fnm );
++CompInfo.compfile_max;
if( CompInfo.compfile_max == CompInfo.compfile_cur ) {
if( WholeFName == NULL ) {
stvcpy( filename, fnm, len );
StripQuotes( filename );
WholeFName = FNameAdd( filename );
} else {
CErr1( ERR_CAN_ONLY_COMPILE_ONE_FILE );
}
}
}
local void CElse( void )
{
if( ( NestLevel == 0 ) || ( CppStack->cpp_type == PRE_ELSE ) ) {
CErr1( ERR_MISPLACED_ELSE );
} else {
if( NestLevel == SkipLevel ) {
--SkipLevel; /* start skipping else part */
CppStack->processing = 0;
} else if( NestLevel == SkipLevel + 1 ) {
/* cpp_type will be PRE_ELIF if an elif was true */
if( CppStack->cpp_type == PRE_IF ) { /* 19-sep-88 */
SkipLevel = NestLevel; /* start including else part */
CppStack->processing = 1;
}
}
CppStack->cpp_type = PRE_ELSE;
}
PPNextToken();
WantEOL();
}
local DATA_QUAD_LIST *NewDataQuad( void )
{
static DATA_QUAD_LIST *DataQuadPtr;
DATA_QUAD_LIST *dql;
if( DataQuadIndex >= (DATA_QUADS_PER_SEG - 1) ) {
if( DataQuadSegIndex == MAX_DATA_QUAD_SEGS ) {
CErr1( ERR_INTERNAL_LIMIT_EXCEEDED );
CSuicide();
}
++DataQuadSegIndex;
DataQuadIndex = 0;
DataQuadPtr = FEmalloc( DATA_QUAD_SEG_SIZE );
DataQuadSegs[ DataQuadSegIndex ] = DataQuadPtr;
}
dql = DataQuadPtr;
++DataQuadIndex;
++DataQuadPtr;
return dql;
}
static void ReturnStmt( SYM_HANDLE func_result, struct return_info *info )
{
TREEPTR tree;
BLOCKPTR block;
enum return_with with;
NextToken();
if( CurToken != T_SEMI_COLON ) {
TYPEPTR func_type;
func_type = CurFunc->sym_type->object;
SKIP_TYPEDEFS( func_type );
tree = RValue( Expr() );
ChkRetType( tree );
tree = BoolConv( func_type, tree );
tree = FixupAss( tree, func_type );
tree = ExprNode( 0, OPR_RETURN, tree );
tree->expr_type = func_type;
tree->op.sym_handle = func_result;
AddStmt( tree );
with = RETURN_WITH_EXPR;
info->with_expr = TRUE;
} else {
with = RETURN_WITH_NO_EXPR;
}
if( info->with == RETURN_WITH_NONE ) {
info->with = with;
}
if( info->with != with ) {
CErr1( ERR_INCONSISTENT_USE_OF_RETURN );
}
block = BlockStack; /* 16-apr-94 */
while( block != NULL ) {
if( (block->block_type == T__TRY) || (block->block_type == T___TRY) )
break;
block = block->prev_block;
}
if( block != NULL ) {
UnWindTry( -1 );
}
}
static void displayDiagInfo( // DISPLAY DIAG_INFO FOR ARGUMENT
DIAG_INFO* diag, // - diagnostic information
unsigned msg, // - error message
PTREE expr, // - expression
SYMBOL orig ) // - original function
{
ConversionTypesSet( diag->bad_src, diag->bad_tgt );
PTreeErrorExpr( expr, msg );
InfSymbolDeclaration( orig );
if( diag->bad_parm == 0 ) {
CErr1( INF_THIS_MISMATCH );
ConversionDiagnoseInf();
} else if( diag->bad_fn == NULL ) {
displayParmMismatch( diag );
ConversionDiagnoseInf();
} else {
displayParmMismatch( diag );
CErr2p( INF_BAD_FN_OVERLOAD, diag->bad_fn );
ConversionDiagnoseInfTgt();
}
}
local void CEndif( void )
{
if( NestLevel == 0 ) {
CErr1( ERR_MISPLACED_ENDIF );
} else {
struct cpp_info *cpp;
--NestLevel;
cpp = CppStack;
if( cpp->flist != SrcFile->src_flist ) {
CWarn2p( WARN_LEVEL_1, ERR_WEIRD_ENDIF_ENCOUNTER, FileIndexToCorrectName( cpp->src_loc.fno ) );
}
CppStack = cpp->prev_cpp;
CMemFree( cpp );
}
if( NestLevel < SkipLevel ) {
SkipLevel = NestLevel;
}
PPNextToken();
WantEOL();
}
void ParsePgm( void )
{
SYM_HANDLE dummysym;
CompFlags.external_defn_found = 0;
CompFlags.initializing_data = 0;
dummysym = SYM_NULL;
GlobalSym = SYM_NULL;
do {
if( DeclList( &dummysym ) ) { /* if this is a function defn */
FuncDefn( CurFunc );
SrcLoc = CurFunc->src_loc;
GenFunctionNode( CurFuncHandle );
SymLevel = 1;
ParmDeclList();
SymLevel = 0;
if( CurToken == T_LEFT_BRACE ) {
BeginFunc();
Statement();
CMemFree( CurFunc->name );
CurFunc->name = NULL;
SymReplace( CurFunc, CurFuncHandle );
CurFunc = NULL;
CurFuncNode = NULL;
CurFuncHandle = SYM_NULL;
} else {
MustRecog( T_LEFT_BRACE );
}
}
} while( CurToken != T_EOF );
if( CompFlags.external_defn_found == 0 ) {
if( !CompFlags.extensions_enabled ) {
CErr1( ERR_NO_EXTERNAL_DEFNS_FOUND );
}
}
}
static void miscAnalysis( OPT_STORAGE *data )
{
#if _CPU == 8086
if( data->bd || data->zu ) {
if( TargetSwitches & SMART_WINDOWS ) {
CErr1( ERR_ZWS_MUST_HAVE_SS_DS_SAME );
}
}
#endif
if( GET_CPU( CpuSwitches ) < CPU_386 ) {
/* issue warning message if /zf[f|p] or /zg[f|p] spec'd? */
TargetSwitches &= ~( FLOATING_FS | FLOATING_GS );
}
if( ! CompFlags.save_restore_segregs ) {
if( TargetSwitches & FLOATING_DS ) {
HW_CTurnOff( WatcallInfo.save, HW_DS );
}
if( TargetSwitches & FLOATING_ES ) {
HW_CTurnOff( WatcallInfo.save, HW_ES );
}
if( TargetSwitches & FLOATING_FS ) {
HW_CTurnOff( WatcallInfo.save, HW_FS );
}
if( TargetSwitches & FLOATING_GS ) {
HW_CTurnOff( WatcallInfo.save, HW_GS );
}
}
if( GET_FPU( CpuSwitches ) > FPU_NONE ) {
PreDefineStringMacro( "__FPI__" );
}
#if _CPU == 386
if( ! CompFlags.register_conventions ) {
SetAuxStackConventions();
}
#endif
if( data->zx ) {
HW_CTurnOff( WatcallInfo.save, HW_FLTS );
}
}
int ChkCompatibleFunction( TYPEPTR typ1, TYPEPTR typ2, int topLevelCheck )
{
TYPEPTR *plist1;
TYPEPTR *plist2;
int parm_count;
plist1 = typ1->u.fn.parms;
plist2 = typ2->u.fn.parms;
if( plist1 != plist2 ) {
if( plist1 == NULL ) {
return( ChkParmPromotion( plist2, topLevelCheck ) );
} else if( plist2 == NULL ) {
return( ChkParmPromotion( plist1, topLevelCheck ) );
}
parm_count = 1;
for( ;; ) {
if( *plist1 == NULL && *plist2 == NULL )
break;
if( *plist1 == NULL || *plist2 == NULL ) {
if( topLevelCheck ) {
CErr1( ERR_PARM_COUNT_MISMATCH );
}
return( TC_PARM_COUNT_MISMATCH );
}
if( ! IdenticalType( *plist1, *plist2 ) ) {
if( topLevelCheck ) {
SetDiagType2( *plist1, *plist2 );
CErr2( ERR_PARM_TYPE_MISMATCH, parm_count );
SetDiagPop();
}
return( TC_PARM_TYPE_MISMATCH + parm_count );
}
++plist1;
++plist2;
++parm_count;
}
}
return( TC_OK ); /* indicate functions are compatible */
}
local void StoreInt64( TYPEPTR typ )
{
TREEPTR tree;
DATA_QUAD dq;
dq.type = typ->decl_type;
dq.flags = Q_DATA;
U32ToU64( 0, &dq.u.long64 );
if( CurToken != T_RIGHT_BRACE ) {
tree = SingleExpr();
tree = InitAsgn( typ, tree ); // as if we are assigning
if( tree->op.opr == OPR_PUSHINT || tree->op.opr == OPR_PUSHFLOAT ) {
CastConstValue( tree, typ->decl_type );
dq.u.long64 = tree->op.ulong64_value;
} else {
CErr1( ERR_NOT_A_CONSTANT_EXPR );
}
FreeExprTree( tree );
CompFlags.non_zero_data = 1;
}
GenDataQuad( &dq, sizeof( int64 ) );
}
hw_reg_set *PragManyRegSets( void )
/*********************************/
{
int i;
hw_reg_set list;
hw_reg_set *sets;
hw_reg_set buff[ MAXIMUM_PARMSETS ];
list = PragRegList();
i = 0;
while( !HW_CEqual( list, HW_EMPTY ) && ( i != MAXIMUM_PARMSETS ) ) {
buff[ i++ ] = list;
list = PragRegList();
}
if( !HW_CEqual( list, HW_EMPTY ) ) {
CErr1( ERR_TOO_MANY_PARM_SETS );
}
HW_CAsgn( buff[ i ], HW_EMPTY );
i++;
i *= sizeof( hw_reg_set );
sets = (hw_reg_set *)CMemAlloc( i );
memcpy( sets, buff, i );
return( sets );
}
