TOKEN ChkControl( void )
{
int lines_skipped;
ppctl_t old_ppctl;
if( !CompFlags.doing_macro_expansion ) {
if( CompFlags.cpp_output ) {
PrintWhiteSpace = FALSE;
}
}
while( CurrChar == '\n' ) {
if( TBreak() ) {
CErr1( ERR_BREAK_KEY_HIT );
CSuicide();
}
lines_skipped = 0;
old_ppctl = CompFlags.pre_processing;
for( ; CurrChar != EOF_CHAR; ) {
if( CompFlags.cpp_output ) {
CppPrtChar( '\n' );
}
NextChar();
if( CurrChar != PreProcChar ) {
SkipAhead();
}
if( CurrChar == EOF_CHAR )
break;
if( CurrChar == PreProcChar ) { /* start of comp control line */
PPCTL_ENABLE_EOL();
PPCTL_DISABLE_MACROS();
PreProcStmt();
PPFlush2EOL();
CompFlags.pre_processing = old_ppctl;
} else if( NestLevel != SkipLevel ) {
PPCTL_ENABLE_EOL();
PPCTL_DISABLE_MACROS();
PPNextToken(); /* get into token mode */
PPFlush2EOL();
CompFlags.pre_processing = old_ppctl;
}
if( NestLevel == SkipLevel )
break;
if( CurrChar == '\n' ) {
lines_skipped = 1;
}
}
if( CompFlags.cpp_output ) {
if( lines_skipped ) {
if( SrcFile != NULL ) { /* 14-may-92 */
EmitLine( SrcFile->src_loc.line, SrcFile->src_name );
}
}
}
}
// we have already skipped past all white space at the start of the line
CurToken = T_WHITE_SPACE;
// CurToken = ScanToken();
return( T_WHITE_SPACE );
}
void CInclude( void )
{
char in_macro;
auto char buf[ 82 ];
if( PCH_FileName != NULL && CompFlags.make_precompiled_header == 0 ) {
if( CompFlags.ok_to_use_precompiled_hdr ) { /* 27-jun-94 */
CompFlags.use_precompiled_header = 1;
}
}
if( CompFlags.use_precompiled_header ) {
InitBuildPreCompiledHeader();
}
InitialMacroFlag = MFLAG_NONE;
in_macro = 0;
if( MacroPtr != NULL )
in_macro = 1;
PPCTL_ENABLE_MACROS();
PPNextToken();
PPCTL_DISABLE_MACROS();
if( CurToken == T_STRING ) {
OpenSrcFile( Buffer, FALSE );
#if _CPU == 370
if( !CompFlags.use_precompiled_header ) {
SrcFile->colum = Column; /* do trunc and col on */
SrcFile->trunc = Trunc; /* on user source files */
}
#endif
} else if( CurToken == T_LT ) {
if( in_macro ) {
PPCTL_ENABLE_MACROS();
}
buf[ 0 ] = '\0';
for( ;; ) {
PPNextToken();
if( CurToken == T_GT ) {
OpenSrcFile( buf, TRUE );
break;
}
strncat( buf, Buffer, sizeof( buf ) - 2 );
if( in_macro != 0 && MacroPtr == NULL || CurToken == T_NULL || CurToken == T_EOF ) {
CErr1( ERR_INVALID_INCLUDE );
break;
}
}
if( in_macro ) {
PPCTL_DISABLE_MACROS();
}
} else {
CErr1( ERR_INVALID_INCLUDE );
}
if( CurToken != T_EOF ) {
PPNextToken();
}
CompFlags.use_precompiled_header = 0;
}
static void PragDataSeg( void ) /* 22-oct-92 */
/*****************************/
{
char *segname;
segment_id segment;
if( CurToken == T_LEFT_PAREN ) {
PPCTL_ENABLE_MACROS();
segment = 0;
NextToken();
if( ( CurToken == T_STRING ) || ( CurToken == T_ID ) ) {
segname = CStrSave( Buffer );
NextToken();
if( CurToken == T_COMMA ) {
NextToken();
if( ( CurToken == T_STRING ) || ( CurToken == T_ID ) ) {
segment = AddSegName( segname, Buffer, SEGTYPE_DATA );
NextToken();
} else {
segment = AddSegName( segname, NULL, SEGTYPE_DATA );
}
} else {
segment = AddSegName( segname, NULL, SEGTYPE_DATA );
}
CMemFree( segname );
}
PPCTL_DISABLE_MACROS();
MustRecog( T_RIGHT_PAREN );
DefDataSegment = segment;
}
}
MEPTR DefineCmdLineMacro( // DEFINE A MACRO FROM THE COMMAND LINE
// (assumes position is one char after "-D")
bool many_tokes ) // - true ==> scan multiple tokens
{
MEPTR mptr;
int (*old_scanner)( void );
ppctl_t old_ppctl;
old_scanner = NextChar;
old_ppctl = PPControl;
NextChar = &SrcFileCmdLnGetChar;
PPCTL_ENABLE_EOL();
PPCTL_DISABLE_MACROS();
SrcFileCmdLnDummyOpen();
CurrChar = NextChar();
if( many_tokes ) {
mptr = MacroScan( MSCAN_CMDLN_PLUS );
} else {
mptr = MacroScan( MSCAN_CMDLN_NORMAL );
}
SrcFileCmdLnDummyClose();
NextChar = old_scanner;
PPControl = old_ppctl;
return( mptr );
}
hw_reg_set PragRegList( // GET PRAGMA REGISTER SET
void )
{
hw_reg_set res; // - resultant set
hw_reg_set reg; // - current set
TOKEN close_token; // - ending delimiter
HW_CAsgn( res, HW_EMPTY );
if( CurToken == T_LEFT_BRACKET ) {
close_token = T_RIGHT_BRACKET;
} else if( CurToken == T_LEFT_BRACE ) {
close_token = T_RIGHT_BRACE;
} else {
return( res );
}
PPCTL_ENABLE_MACROS();
NextToken();
for( ; CurToken != close_token; ) {
reg = PragRegName( Buffer, strlen( Buffer ) );
HW_TurnOn( res, reg );
NextToken();
}
PPCTL_DISABLE_MACROS();
MustRecog( close_token );
return( res );
}
local void CElif( void )
{
int value;
PPCTL_ENABLE_MACROS();
PPNextToken();
if( ( NestLevel == 0 ) || ( CppStack->cpp_type == PRE_ELSE ) ) {
CErr1( ERR_MISPLACED_ELIF );
} else {
if( NestLevel == SkipLevel ) {
--SkipLevel; /* start skipping else part */
CppStack->processing = 0;
CppStack->cpp_type = PRE_ELIF;
} else if( NestLevel == SkipLevel + 1 ) {
/* only evaluate the expression when required */
if( CppStack->cpp_type == PRE_IF ) {
value = GetConstExpr();
ChkEOL();
if( value ) {
SkipLevel = NestLevel; /* start including else part */
CppStack->processing = 1;
CppStack->cpp_type = PRE_ELIF;
}
}
}
}
PPCTL_DISABLE_MACROS();
}
hw_reg_set PragRegList( void )
/****************************/
{
hw_reg_set res, reg;
TOKEN close;
char buf[ 80 ];
HW_CAsgn( res, HW_EMPTY );
HW_CAsgn( reg, HW_EMPTY );
close = PragRegSet();
if( close != T_NULL ) {
PPCTL_ENABLE_MACROS();
NextToken();
*buf = '\0';
for( ; CurToken != close; ) {
strcat( buf, Buffer );
if( CurToken != T_BAD_CHAR ) {
reg = PragRegName( buf );
HW_TurnOn( res, reg );
*buf = '\0';
}
NextToken();
}
PPCTL_DISABLE_MACROS();
MustRecog( close );
}
return( res );
}
local void getPackArgs( void )
/****************************/
{
struct pack_info *pi;
/* check to make sure it is a numeric token */
if( PragIdRecog( "push" ) ) { /* 29-sep-94 */
pi = (struct pack_info *)CMemAlloc( sizeof( struct pack_info ) );
pi->next = PackInfo;
pi->pack_amount = PackAmount;
PackInfo = pi;
if( CurToken == T_COMMA ) {
PPCTL_ENABLE_MACROS();
NextToken();
PPCTL_DISABLE_MACROS();
if( ExpectingConstant() ) {
SetPackAmount();
}
NextToken();
}
} else if( PragIdRecog( "pop" ) ) {
pi = PackInfo;
if( pi != NULL ) {
PackAmount = pi->pack_amount;
PackInfo = pi->next;
CMemFree( pi );
}
} else {
CErr1( ERR_NOT_A_CONSTANT_EXPR );
}
}
// form: #pragma include_alias( "alias_name", "real_name" )
// #pragma include_alias( <alias_name>, <real_name> )
//
// (1) causes include directives referencing alias_name to refer
// to real_name instead
//
static void pragIncludeAlias( void )
{
if( ExpectingToken( T_LEFT_PAREN ) ) {
PPCTL_ENABLE_MACROS();
NextToken();
if( CurToken == T_STRING ) {
char *alias_name;
alias_name = CMemAlloc( strlen( Buffer ) + 1 );
strcpy( alias_name, Buffer );
NextToken();
if( ExpectingToken( T_COMMA ) ) {
NextToken();
}
if( CurToken == T_STRING ) {
IAliasAdd( alias_name, Buffer, false );
NextToken();
}
CMemFree( alias_name );
} else if( CurToken == T_LT ) {
char a_buf[82];
char r_buf[82];
a_buf[0] = '\0';
for( ;; ) {
NextToken();
if( CurToken == T_GT ) {
NextToken();
break;
}
if( CurToken == T_NULL ) {
break;
}
strncat( a_buf, Buffer, sizeof( a_buf ) - 2 );
}
if( ExpectingToken( T_COMMA ) ) {
NextToken();
}
if( CurToken == T_LT ) {
r_buf[0] = '\0';
for( ;; ) {
NextToken();
if( CurToken == T_GT ) {
NextToken();
break;
}
if( CurToken == T_NULL ) {
break;
}
strncat( r_buf, Buffer, sizeof( r_buf ) - 2 );
}
IAliasAdd( a_buf, r_buf, true );
}
}
PPCTL_DISABLE_MACROS();
MustRecog( T_RIGHT_PAREN );
}
}
// #pragma alias(id1/"name1", id2/"name2")
//
// Causes linker to replace references to id1/name1 with references
// to id2/name2. Both the alias and the substituted symbol may be defined
// either as a string name or an id of existing symbol.
//
static void PragAlias( void )
/***************************/
{
SYM_HANDLE alias_sym;
SYM_HANDLE subst_sym;
const char *alias_name;
const char *subst_name;
alias_list **alias;
alias_list *new_alias;
alias_name = subst_name = NULL;
alias_sym = subst_sym = NULL;
if( ExpectingToken( T_LEFT_PAREN ) ) {
PPCTL_ENABLE_MACROS();
PPNextToken();
if( CurToken == T_ID ) {
alias_sym = SymLook( HashValue, Buffer );
if( alias_sym == 0 ) {
CErr2p( ERR_UNDECLARED_SYM, Buffer );
}
} else if( CurToken == T_STRING ) {
alias_name = CStrSave( Buffer );
}
PPNextToken();
MustRecog( T_COMMA );
if( CurToken == T_ID ) {
subst_sym = SymLook( HashValue, Buffer );
if( subst_sym == 0 ) {
CErr2p( ERR_UNDECLARED_SYM, Buffer );
}
} else if( CurToken == T_STRING ) {
subst_name = CStrSave( Buffer );
}
PPNextToken();
PPCTL_DISABLE_MACROS();
MustRecog( T_RIGHT_PAREN );
}
/* Add a new alias record - if it's valid - to the list */
if( ( alias_name != NULL || alias_sym != NULL ) && ( subst_name != NULL || subst_sym != NULL ) ) {
for( alias = &AliasHead; *alias != NULL; alias = &(*alias)->next )
; /* nothing to do */
new_alias = (void *)CMemAlloc( sizeof( alias_list ) );
new_alias->next = NULL;
if( alias_name ) {
new_alias->name = alias_name;
} else {
new_alias->a_sym = alias_sym;
}
if( subst_name ) {
new_alias->subst = subst_name;
} else {
new_alias->s_sym = subst_sym;
}
*alias = new_alias;
}
}
static void pragPack( // #PRAGMA PACK
void )
{
if( ExpectingToken( T_LEFT_PAREN ) ) {
PPCTL_ENABLE_MACROS();
NextToken();
PPCTL_DISABLE_MACROS();
switch( CurToken ) {
case T_ID:
if( PragIdRecog( "pop" ) ) {
popPrag( &HeadPacks, &PackAmount );
} else if( PragIdRecog( "push" ) ) {
if( CurToken == T_RIGHT_PAREN ) {
pushPrag( &HeadPacks, PackAmount );
} else {
if( ExpectingToken( T_COMMA ) ) {
PPCTL_ENABLE_MACROS();
NextToken();
PPCTL_DISABLE_MACROS();
}
if( CurToken == T_CONSTANT ) {
pushPrag( &HeadPacks, PackAmount );
PackAmount = VerifyPackAmount( U32Fetch( Constant64 ) );
NextToken();
} else {
MustRecog( T_CONSTANT );
}
}
} else {
CErr( ERR_EXPECTING_BUT_FOUND, "push or pop", Buffer );
}
break;
case T_CONSTANT:
PackAmount = VerifyPackAmount( U32Fetch( Constant64 ) );
NextToken();
break;
case T_RIGHT_PAREN:
PackAmount = GblPackAmount;
break;
default:
break;
}
MustRecog( T_RIGHT_PAREN );
}
}
static bool startPragRecog( char *id )
{
bool retb;
PPCTL_ENABLE_MACROS();
retb = PragIdRecog( id );
PPCTL_DISABLE_MACROS();
return( retb );
}
local int startPragRecog( char *what )
/************************************/
{
int rc;
PPCTL_ENABLE_MACROS();
rc = PragIdRecog( what );
PPCTL_DISABLE_MACROS();
return( rc );
}
// forms: (1) #pragma include_alias( "alias_name", "real_name" )
// (2) #pragma include_alias( <alias_name>, <real_name> )
//
// causes include directives referencing alias_name to be refer
// to real_name instead
//
static void PragIncludeAlias( void )
/**********************************/
{
if( ExpectingToken( T_LEFT_PAREN ) ) {
PPCTL_ENABLE_MACROS();
NextToken();
if( CurToken == T_STRING ) {
char *alias_name;
alias_name = CStrSave( Buffer );
NextToken();
MustRecog( T_COMMA );
if( CurToken == T_STRING ) {
SrcFileIncludeAlias( alias_name, Buffer, FALSE );
NextToken();
}
CMemFree( alias_name );
} else if( CurToken == T_LT ) {
char a_buf[ 82 ]; /* same size as CInclude() in cmac2.c */
char r_buf[ 82 ];
a_buf[ 0 ] = '\0';
for( ;; ) {
NextToken();
if( CurToken == T_GT ) {
NextToken();
break;
}
if( CurToken == T_NULL ) {
break;
}
strncat( a_buf, Buffer, sizeof( a_buf ) - 2 );
}
MustRecog( T_COMMA );
if( CurToken == T_LT ) {
r_buf[ 0 ] = '\0';
for( ;; ) {
NextToken();
if( CurToken == T_GT ) {
NextToken();
break;
}
if( CurToken == T_NULL ) {
break;
}
strncat( r_buf, Buffer, sizeof( r_buf ) - 2 );
}
SrcFileIncludeAlias( a_buf, r_buf, TRUE );
}
}
PPCTL_DISABLE_MACROS();
MustRecog( T_RIGHT_PAREN );
}
}
local void CIf( void )
{
int value;
PPCTL_ENABLE_MACROS();
PPNextToken();
value = GetConstExpr();
IncLevel( value );
ChkEOL();
PPCTL_DISABLE_MACROS();
}
// form:
// #pragma message ("one or more " "long message " "strings")
// output these strings to stdout
// this output is _not_ dependent on setting
// of #pragma enable_message or disable_message.
static void PragMessage( void )
/*****************************/
{
if( ExpectingToken( T_LEFT_PAREN ) ) {
PPCTL_ENABLE_MACROS();
while( NextToken() == T_STRING ) {
printf( "%s", Buffer );
}
printf( "\n" );
PPCTL_DISABLE_MACROS();
MustRecog( T_RIGHT_PAREN );
}
}
static void pragError( // #PRAGMA ERROR
void )
{
VBUF str;
if( CurToken == T_STRING ) {
PPCTL_ENABLE_MACROS();
collectStrings( &str );
CErr2p( ERR_USER_ERROR_MSG, VbufString( &str ) );
VbufFree( &str );
PPCTL_DISABLE_MACROS();
}
}
static void pragMessage( // #PRAGMA MESSAGE
void )
{
VBUF str;
if( ExpectingToken( T_LEFT_PAREN ) ) {
PPCTL_ENABLE_MACROS();
NextToken();
if( CurToken == T_STRING ) {
collectStrings( &str );
CErr2p( WARN_USER_WARNING_MSG, VbufString( &str ) );
VbufFree( &str );
}
PPCTL_DISABLE_MACROS();
MustRecog( T_RIGHT_PAREN );
}
}
local void PragPack( void )
/*************************/
{
if( ExpectingToken( T_LEFT_PAREN ) ) {
PPCTL_ENABLE_MACROS();
NextToken();
PPCTL_DISABLE_MACROS();
if( CurToken == T_CONSTANT ) {
SetPackAmount();
NextToken();
} else if( IS_ID_OR_KEYWORD( CurToken ) ) {
getPackArgs();
} else if( CurToken == T_RIGHT_PAREN ) {
PackAmount = GblPackAmount;
}
MustRecog( T_RIGHT_PAREN );
}
}
local void CLine( void )
{
FNAMEPTR flist;
unsigned long src_line;
src_line = 0;
PPCTL_ENABLE_MACROS();
PPNextToken();
if( ExpectingConstant() ) {
if( CompFlags.cpp_ignore_line == 0 ) {
src_line = Constant; // stash in case of side effects
SrcFile->src_loc.line = src_line - 1; /* don't count this line */
}
PPNextToken();
if( CurToken == T_NULL ) {
if( CompFlags.cpp_ignore_line == 0 ) {
if( CompFlags.cpp_output ) {
EmitLine( src_line, SrcFile->src_name );
}
}
} else {
if( ExpectingToken( T_STRING ) ) {
if( CompFlags.wide_char_string ) {
/* wide char string not allowed */
ExpectString();
} else {
if( CompFlags.cpp_ignore_line == 0 ) {
// RemoveEscapes( Buffer );
flist = AddFlist( Buffer );
flist->rwflag = FALSE; // not a real file so no autodep
SrcFile->src_name = flist->name;
SrcFile->src_loc.fno = flist->index;
if( CompFlags.cpp_output ) {
EmitLine( src_line, SrcFile->src_name );
}
}
}
}
PPNextToken();
ChkEOL();
}
}
PPCTL_DISABLE_MACROS();
}
static void pragExtRef( // #pragma extref ...
void )
{
if( CurToken == T_LEFT_PAREN ) {
do {
PPCTL_ENABLE_MACROS();
NextToken();
PPCTL_DISABLE_MACROS();
if( !IS_ID_OR_KEYWORD( CurToken ) && CurToken != T_STRING )
break;
parseExtRef();
NextToken();
} while( CurToken == T_COMMA );
MustRecog( T_RIGHT_PAREN );
} else if( IS_ID_OR_KEYWORD( CurToken ) || CurToken == T_STRING ) {
parseExtRef();
NextToken();
}
}
static void pragComment( // #PRAGMA COMMENT
void )
{
if( ExpectingToken( T_LEFT_PAREN ) ) {
NextToken();
if( PragRecog( "lib" ) ) {
PPCTL_ENABLE_MACROS();
if( ExpectingToken( T_COMMA ) ) {
NextToken();
}
while( IS_ID_OR_KEYWORD( CurToken ) || CurToken == T_STRING ) {
CgInfoAddUserLib( Buffer );
NextToken();
}
PPCTL_DISABLE_MACROS();
}
MustRecog( T_RIGHT_PAREN );
}
}
static void PragCodeSeg( void ) /* 22-oct-92 */
/*****************************/
{
textsegment *seg;
char *segname;
char *classname;
if( CurToken == T_LEFT_PAREN ) {
PPCTL_ENABLE_MACROS();
seg = NULL;
NextToken();
if( ( CurToken == T_STRING ) || ( CurToken == T_ID ) ) {
segname = CStrSave( Buffer );
classname = CStrSave( "" );
NextToken();
if( CurToken == T_COMMA ) {
NextToken();
if( ( CurToken == T_STRING ) || ( CurToken == T_ID ) ) {
CMemFree( classname );
classname = CStrSave( Buffer );
// CodeClassName = CStrSave( Buffer ); /* 13-apr-93 */
NextToken();
}
}
seg = LkSegName( segname, classname );
CMemFree( segname );
CMemFree( classname );
}
PPCTL_DISABLE_MACROS();
MustRecog( T_RIGHT_PAREN );
DefCodeSegment = seg;
#if _CPU == 8086 || _CPU == 386
CompFlags.multiple_code_segments = 1;
#endif
}
}
// #pragma data_seg ( segment [, class] )
// #pragma data_seg segment
//
// "segment" sets the default data segment for remaining objects
// "class" is ignored
//
static void pragDataSeg( // SET NEW DATA SEGMENT
void )
{
char *seg_name;
char *seg_class;
if( CurToken == T_LEFT_PAREN ) {
PPCTL_ENABLE_MACROS();
NextToken();
if( ( CurToken == T_STRING ) || ( CurToken == T_ID ) ) {
seg_name = strsave( Buffer );
seg_class = NULL;
NextToken();
if( CurToken == T_COMMA ) {
NextToken();
if( ( CurToken == T_STRING ) || ( CurToken == T_ID ) ) {
seg_class = strsave( Buffer );
NextToken();
} else {
MustRecog( T_STRING );
}
}
SegmentData( seg_name, seg_class );
CMemFree( seg_name );
CMemFree( seg_class );
} else if( CurToken == T_RIGHT_PAREN ) {
// restore back to default behaviour
SegmentData( NULL, NULL );
}
PPCTL_DISABLE_MACROS();
MustRecog( T_RIGHT_PAREN );
} else if( CurToken == T_STRING ) {
SegmentData( Buffer, NULL );
NextToken();
}
}
static int GetByteSeq( void )
{
int len;
char *name;
unsigned offset;
unsigned fixword;
int uses_auto;
VBUF code_buffer;
#if _CPU == 8086
bool use_fpu_emu = FALSE;
#endif
VbufInit( &code_buffer );
AsmSysInit();
PPCTL_ENABLE_MACROS();
NextToken();
len = 0;
offset = 0;
name = NULL;
for( ;; ) {
/* reserve at least ASM_BLOCK bytes in the buffer */
VbufReqd( &code_buffer, _RoundUp( len + ASM_BLOCK, ASM_BLOCK ) );
if( CurToken == T_STRING ) {
AsmCodeAddress = len;
AsmCodeBuffer = VbufBuffer( &code_buffer );
#if _CPU == 8086
AsmLine( Buffer, use_fpu_emu );
use_fpu_emu = FALSE;
#else
AsmLine( Buffer, FALSE );
#endif
len = AsmCodeAddress;
NextToken();
if( CurToken == T_COMMA ) {
NextToken();
}
} else if( CurToken == T_CONSTANT ) {
#if _CPU == 8086
if( use_fpu_emu ) {
AddAFix( len, NULL, FIX_SEG, 0 );
use_fpu_emu = FALSE;
}
#endif
VbufBuffer( &code_buffer )[ len++ ] = U32Fetch( Constant64 );
NextToken();
} else {
#if _CPU == 8086
use_fpu_emu = FALSE;
#endif
fixword = FixupKeyword();
if( fixword == FIXWORD_NONE )
break;
if( fixword == FIXWORD_FLOAT ) {
#if _CPU == 8086
if( GET_FPU_EMU( CpuSwitches ) ) {
use_fpu_emu = TRUE;
}
#endif
} else { /* seg or offset */
if( !IS_ID_OR_KEYWORD( CurToken ) ) {
CErr1( ERR_EXPECTING_ID );
} else {
name = strsave( Buffer );
offset = 0;
NextToken();
if( CurToken == T_PLUS ) {
NextToken();
if( CurToken == T_CONSTANT ) {
offset = U32Fetch( Constant64 );
NextToken();
}
} else if( CurToken == T_MINUS ) {
NextToken();
if( CurToken == T_CONSTANT ) {
offset = - U32Fetch( Constant64 );
NextToken();
}
}
}
switch( fixword ) {
case FIXWORD_RELOFF:
#if _CPU == 8086
AddAFix( len, name, FIX_RELOFF16, offset );
len += 2;
#else
AddAFix( len, name, FIX_RELOFF32, offset );
len += 4;
#endif
break;
case FIXWORD_OFFSET:
#if _CPU == 8086
AddAFix( len, name, FIX_OFF16, offset );
len += 2;
#else
AddAFix( len, name, FIX_OFF32, offset );
len += 4;
#endif
break;
case FIXWORD_SEGMENT:
AddAFix( len, name, FIX_SEG, 0 );
len += 2;
break;
}
}
}
VbufSetLen( &code_buffer, len );
}
PPCTL_DISABLE_MACROS();
uses_auto = AsmSysInsertFixups( &code_buffer );
AsmSysFini();
VbufFree( &code_buffer );
return( uses_auto );
}
void CPragma( void )
/******************/
{
bool check_end = TRUE;
/* Note that the include_alias pragma must always be processed
* because it's intended for the preprocessor, not the compiler.
*/
CompFlags.in_pragma = 1;
NextToken();
if( PragRecog( "include_alias" ) ) {
PragIncludeAlias();
} else if( CompFlags.cpp_output ) {
PPCTL_ENABLE_MACROS();
CppPrtf( "#pragma " );
for( ; CurToken != T_NULL; ) {
CppPrtToken();
GetNextToken();
}
PPCTL_DISABLE_MACROS();
} else if( IS_ID_OR_KEYWORD( CurToken ) ) {
if( PragIdRecog( "on" ) ) {
PragFlag( 1 );
} else if( PragIdRecog( "off" ) ) {
PragFlag( 0 );
} else if( PragIdRecog( "aux" ) || PragIdRecog( "linkage" ) ) {
PragAux();
} else if( PragIdRecog( "library" ) ) {
PragLibs();
} else if( PragIdRecog( "comment" ) ) {
PragComment();
} else if( PragIdRecog( "pack" ) ) {
PragPack();
} else if( PragIdRecog( "alloc_text" ) ) {
PragAllocText();
} else if( PragIdRecog( "code_seg" ) ) {
PragCodeSeg();
} else if( PragIdRecog( "data_seg" ) ) {
PragDataSeg();
} else if( PragIdRecog( "disable_message" ) ) {
PragEnableDisableMessage( 0 );
} else if( PragIdRecog( "enable_message" ) ) {
PragEnableDisableMessage( 1 );
} else if( PragIdRecog( "include_alias" ) ) {
PragIncludeAlias();
} else if( PragIdRecog( "message" ) ) {
PragMessage();
} else if( PragIdRecog( "intrinsic" ) ) {
PragIntrinsic( 1 );
} else if( PragIdRecog( "function" ) ) {
PragIntrinsic( 0 );
} else if( PragIdRecog( "enum" ) ) {
PragEnum();
} else if( startPragRecog( "read_only_file" ) ) {
PragReadOnlyFile();
} else if( startPragRecog( "read_only_directory" ) ) {
PragReadOnlyDir();
} else if( PragIdRecog( "once" ) ) {
PragOnce();
} else if( PragIdRecog( "unroll" ) ) {
PragUnroll();
} else if( PragIdRecog( "STDC" ) ) {
PragSTDC();
} else if( PragIdRecog( "extref" ) ) {
PragExtRef();
} else if( PragIdRecog( "alias" ) ) {
PragAlias();
} else {
check_end = FALSE;
}
} else {
check_end = FALSE;
}
if( check_end )
EndOfPragma();
CompFlags.in_pragma = 0;
}
void CPragma( void ) // PROCESS A PRAGMA
{
bool check_end = true;
SrcFileGuardStateSig();
CompFlags.in_pragma = 1;
NextToken();
if( PragRecog( "include_alias" ) ) {
pragIncludeAlias();
} else if( CompFlags.cpp_output ) {
PPCTL_ENABLE_MACROS();
fprintf( CppFile, "#pragma " );
for( ; CurToken != T_NULL; ) {
PrtToken();
GetNextToken();
}
PPCTL_DISABLE_MACROS();
} else if( IS_ID_OR_KEYWORD( CurToken ) ) {
if( PragIdRecog( "on" ) ) {
pragFlag( true );
} else if( PragIdRecog( "off" ) ) {
pragFlag( false );
} else if( PragIdRecog( "aux" ) || PragIdRecog( "linkage" ) ) {
PragAux();
} else if( PragIdRecog( "library" ) ) {
pragLibs();
} else if( PragIdRecog( "once" ) ) {
pragOnce();
} else if( PragIdRecog( "extref" ) ) {
pragExtRef();
} else if( PragIdRecog( "comment" ) ) {
pragComment();
} else if( PragIdRecog( "pack" ) ) {
pragPack();
} else if( PragIdRecog( "warning" ) ) {
if( pragWarning() ) {
/* ignore #pragma warning */
check_end = false; /* skip rest of line */
}
} else if( PragIdRecog( "enable_message" ) ) {
pragEnableMessage();
} else if( PragIdRecog( "disable_message" ) ) {
pragDisableMessage();
} else if( PragIdRecog( "code_seg" ) ) {
pragCodeSeg();
} else if( PragIdRecog( "data_seg" ) ) {
pragDataSeg();
} else if( PragIdRecog( "initialize" ) ) {
pragInitialize();
} else if( PragIdRecog( "init_seg" ) ) {
pragInitSeg();
} else if( PragIdRecog( "inline_depth" ) ) {
pragInlineDepth();
} else if( PragIdRecog( "template_depth" ) ) {
pragTemplateDepth();
} else if( PragIdRecog( "inline_recursion" ) ) {
pragInlineRecursion();
} else if( PragIdRecog( "intrinsic" ) ) {
pragIntrinsic( true );
} else if( PragIdRecog( "function" ) ) {
pragIntrinsic( false );
} else if( PragIdRecog( "destruct" ) ) {
pragDestruct();
} else if( PragIdRecog( "enum" ) ) {
pragEnum();
} else if( PragIdRecog( "dump_object_model" ) ) {
pragDumpObjectModel();
} else if( startPragRecog( "read_only_file" ) ) {
pragReadOnlyFile();
} else if( startPragRecog( "read_only_directory" ) ) {
pragReadOnlyDir();
} else if( PragIdRecog( "include_alias" ) ) {
pragIncludeAlias();
} else if( PragIdRecog( "message" ) ) {
pragMessage();
} else if( PragIdRecog( "error" ) ) {
pragError();
#ifndef NDEBUG
} else if( PragIdRecog( "break" ) ) {
pragBreak();
#endif
} else { /* unknown pragma */
check_end = false; /* skip rest of line */
}
} else { /* unknown pragma */
check_end = false; /* skip rest of line */
}
if( check_end ) {
endOfPragma();
}
CompFlags.in_pragma = 0;
}
static bool GetByteSeq( byte_seq **code )
/**************************************/
{
unsigned char buff[MAXIMUM_BYTESEQ + 32];
char *name;
unsigned offset;
fix_words fixword;
bool uses_auto;
bool too_many_bytes;
#if _CPU == 8086
bool use_fpu_emu = false;
#endif
AsmSysInit( buff );
PPCTL_ENABLE_MACROS();
NextToken();
too_many_bytes = false;
uses_auto = false;
offset = 0;
name = NULL;
for( ;; ) {
if( CurToken == T_STRING ) {
#if _CPU == 8086
AsmLine( Buffer, use_fpu_emu );
use_fpu_emu = false;
#else
AsmLine( Buffer, false );
#endif
NextToken();
if( CurToken == T_COMMA ) {
NextToken();
}
} else if( CurToken == T_CONSTANT ) {
#if _CPU == 8086
if( use_fpu_emu ) {
AddAFix( AsmCodeAddress, NULL, FIX_SEG, 0 );
use_fpu_emu = false;
}
#endif
AsmCodeBuffer[AsmCodeAddress++] = (unsigned char)Constant;
NextToken();
} else {
#if _CPU == 8086
use_fpu_emu = false;
#endif
fixword = FixupKeyword();
if( fixword == FIXWORD_NONE )
break;
if( fixword == FIXWORD_FLOAT ) {
#if _CPU == 8086
if( GET_FPU_EMU( ProcRevision ) ) {
use_fpu_emu = true;
}
#endif
} else { /* seg or offset */
if( !IS_ID_OR_KEYWORD( CurToken ) ) {
CErr1( ERR_EXPECTING_ID );
} else {
name = CStrSave( Buffer );
NextToken();
if( CurToken == T_PLUS ) {
NextToken();
if( CurToken == T_CONSTANT ) {
offset = Constant;
NextToken();
}
} else if( CurToken == T_MINUS ) {
NextToken();
if( CurToken == T_CONSTANT ) {
offset = -(int)Constant;
NextToken();
}
}
}
switch( fixword ) {
case FIXWORD_RELOFF:
#if _CPU == 8086
AddAFix( AsmCodeAddress, name, FIX_RELOFF16, offset );
AsmCodeAddress += 2;
#else
AddAFix( AsmCodeAddress, name, FIX_RELOFF32, offset );
AsmCodeAddress += 4;
#endif
break;
case FIXWORD_OFFSET:
#if _CPU == 8086
AddAFix( AsmCodeAddress, name, FIX_OFF16, offset );
AsmCodeAddress += 2;
#else
AddAFix( AsmCodeAddress, name, FIX_OFF32, offset );
AsmCodeAddress += 4;
#endif
break;
case FIXWORD_SEGMENT:
AddAFix( AsmCodeAddress, name, FIX_SEG, 0 );
AsmCodeAddress += 2;
break;
}
}
}
if( AsmCodeAddress > MAXIMUM_BYTESEQ ) {
if( !too_many_bytes ) {
CErr1( ERR_TOO_MANY_BYTES_IN_PRAGMA );
too_many_bytes = true;
}
AsmCodeAddress = 0; // reset index to we don't overrun buffer
}
}
PPCTL_DISABLE_MACROS();
if( too_many_bytes ) {
uses_auto = false;
} else {
uses_auto = InsertFixups( buff, AsmCodeAddress, code );
}
FreeAsmFixups();
AsmSysFini();
return( uses_auto );
}
