static void getAsmLine( VBUF *buff )
{
char line[256];
if( endOfAsmStmt() )
return;
/* reserve at least MAX_INSTR_SIZE bytes in the buffer */
VbufReqd( buff, _RoundUp( ( AsmCodeAddress + MAX_INSTR_SIZE ), MAX_INSTR_SIZE ) );
AsmCodeBuffer = VbufBuffer( buff );
ensureBufferReflectsCurToken();
if( IS_ID_OR_KEYWORD( CurToken ) && strcmp( Buffer, "__emit" ) == 0 ) {
strcpy( line, AsmSysDefineByte() );
strcat( line, " " );
NextToken();
ensureBufferReflectsCurToken();
} else {
line[0] = '\0';
}
for(;;) {
if( endOfAsmStmt() ) break;
strncat( line, Buffer, sizeof(line)-1 );
switch( CurToken ) {
case T_ALT_XOR:
case T_ALT_EXCLAMATION:
case T_ALT_AND_AND:
case T_ALT_OR_OR:
strncat( line, " ", sizeof(line)-1 );
break;
default:
if( IS_ID_OR_KEYWORD( CurToken ) )
strncat( line, " ", sizeof(line)-1 );
break;
}
NextToken();
ensureBufferReflectsCurToken();
}
if( line[0] != '\0' ) {
AsmSysLine( line );
}
VbufSetLen( buff, AsmCodeAddress );
if( CurToken == T_SEMI_COLON ) {
// ; .ASM comment
for(;;) {
NextToken();
if( CurToken == T_EOF ) break;
if( CurToken == T_NULL ) break;
}
}
}
static void PragIntrinsic( int intrinsic ) /* 09-oct-92 */
/****************************************/
{
SYM_HANDLE sym_handle;
SYM_ENTRY sym;
if( ExpectingToken( T_LEFT_PAREN ) ) {
NextToken();
while( IS_ID_OR_KEYWORD( CurToken ) ) {
sym_handle = SymLook( HashValue, Buffer );
if( sym_handle != 0 ) {
SymGet( &sym, sym_handle );
sym.flags &= ~ SYM_INTRINSIC;
if( intrinsic )
sym.flags |= SYM_INTRINSIC;
SymReplace( &sym, sym_handle );
}
NextToken();
if( CurToken != T_COMMA )
break;
NextToken();
}
MustRecog( T_RIGHT_PAREN );
}
}
local void GetLibraryNames( void )
/********************************/
{
while( IS_ID_OR_KEYWORD( CurToken ) || CurToken == T_STRING ) {
AddLibraryName( Buffer, USER_LIB_PRIO );
NextToken();
}
}
int PragRecog( char *what )
/*************************/
{
if( IS_ID_OR_KEYWORD( CurToken ) ) {
return( PragIdRecog( what ) );
}
return( 0 );
}
bool PragRecog( // RECOGNIZE PRAGMA ID
char *what ) // - id
{
if( IS_ID_OR_KEYWORD( CurToken ) ) {
return( PragIdRecog( what ) );
}
return( false );
}
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 pragFlag( // SET TOGGLES
bool set_flag ) // - true ==> set flag
{
if( ExpectingToken( T_LEFT_PAREN ) ) {
NextToken();
while( IS_ID_OR_KEYWORD( CurToken ) ) {
PragmaSetToggle( set_flag );
NextToken();
}
MustRecog( T_RIGHT_PAREN );
}
}
local void PragFlag( int value )
/******************************/
{
if( ExpectingToken( T_LEFT_PAREN ) ) {
NextToken();
while( IS_ID_OR_KEYWORD( CurToken ) ) {
SetToggleFlag( Buffer, value );
NextToken();
}
MustRecog( T_RIGHT_PAREN );
}
}
static bool GetAliasInfo(
void )
{
char buff[256];
bool isfar16;
CurrAlias = &DefaultInfo;
if( CurToken != T_LEFT_PAREN ) // #pragma aux symbol ....
return( IS_ID_OR_KEYWORD( CurToken ) );
NextToken();
if( !IS_ID_OR_KEYWORD( CurToken ) ) // error
return( FALSE );
PragCurrAlias();
strcpy( buff, Buffer );
NextToken();
if( CurToken == T_RIGHT_PAREN ) { // #pragma aux (alias) symbol ....
NextToken();
return( IS_ID_OR_KEYWORD( CurToken ) );
}
if( CurToken == T_COMMA ) { // #pragma aux (alias, symbol)
NextToken();
if( IS_ID_OR_KEYWORD( CurToken ) ) {
isfar16 = PragRecog( "far16" );
CreateAux( buff );
PragCurrAlias();
NextToken();
if( CurToken == T_RIGHT_PAREN ) {
AuxCopy( CurrInfo, CurrAlias );
NextToken();
}
if( isfar16 ) {
CurrInfo->flags |= AUX_FLAG_FAR16;
}
PragEnding( TRUE );
}
}
return( FALSE );
}
static void pragIntrinsic( // SET FUNCTIONS TO BE (NOT TO BE) INTRINSIC
bool intrinsic ) // - true ==> function to be intrinsic
{
if( ExpectingToken( T_LEFT_PAREN ) ) {
NextToken();
while( IS_ID_OR_KEYWORD( CurToken ) ) {
ScopeIntrinsic( intrinsic );
NextToken();
if( CurToken != T_COMMA ) break;
NextToken();
}
MustRecog( T_RIGHT_PAREN );
}
}
static void pragLibs( // #PRAGMA library ( lib ... lib )
void )
{
if( CurToken == T_LEFT_PAREN ) {
NextToken();
while( IS_ID_OR_KEYWORD( CurToken ) || CurToken == T_STRING ) {
CgInfoAddUserLib( Buffer );
NextToken();
}
MustRecog( T_RIGHT_PAREN );
} else {
CompFlags.pragma_library = 1;
}
}
bool GetPragAuxAlias( void )
{
bool isfar16;
isfar16 = PragRecog( "far16" );
if( IS_ID_OR_KEYWORD( CurToken ) ) {
CurrAlias = SearchPragAuxAlias( Buffer );
NextToken();
}
if( CurToken == T_RIGHT_PAREN )
NextToken();
if( isfar16 )
AuxInfo.flags |= AUX_FLAG_FAR16;
CopyAuxInfo();
return( true );
}
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 );
}
}
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 );
}
}
// forms: #pragma extref( symbol [, ...] )
// #pragma extref( "name" [, ...] )
//
// causes a external reference to be emitted for the symbol or "name"
//
static void parseExtRef( // PARSE SYMBOL NAME
void )
{
PRAG_EXT_REF *entry;
if( CurToken == T_STRING ) {
entry = RingAlloc( &pragmaExtrefs, offsetof( PRAG_EXT_REF, name ) + TokenLen + 1 );
memcpy( entry->name, Buffer, TokenLen + 1 );
entry->symbol = NULL;
} else if( IS_ID_OR_KEYWORD( CurToken ) ) {
SEARCH_RESULT* result;
NAME name = NameCreateLen( Buffer, TokenLen );
result = ScopeFindNaked( GetCurrScope(), name );
if( result == NULL ) {
CErr2p( ERR_PRAG_EXTREF_NONE, Buffer );
} else {
SYMBOL_NAME sname = result->sym_name;
SYMBOL sym = sname->name_syms;
ScopeFreeResult( result );
if( sym == NULL ) {
CErr2p( ERR_PRAG_EXTREF_BAD, Buffer );
} else if( SymIsFunction( sym ) ) {
if( IsOverloadedFunc( sym ) ) {
CErr2p( ERR_PRAG_EXTREF_OVERLOADED, sym );
sym = NULL;
}
} else if( SymIsData( sym ) ) {
// no checks now
} else {
CErr2p( ERR_PRAG_EXTREF_BAD, sym );
sym = NULL;
}
if( sym != NULL ) {
entry = RingAlloc( &pragmaExtrefs, offsetof( PRAG_EXT_REF, name ) + 1 );
entry->symbol = sym;
entry->name[0] = '\0';
}
}
}
}
static void pragDumpObjectModel( // DUMP OBJECT MODEL
void )
{
if( IS_ID_OR_KEYWORD( CurToken ) ) {
NAME name = NameCreateLen( Buffer, TokenLen );
SEARCH_RESULT* result = ScopeFindNaked( GetCurrScope(), name );
if( result == NULL ) {
CErr2p( ERR_DUMP_OBJ_MODEL, Buffer );
} else {
SYMBOL_NAME sname = result->sym_name;
ScopeFreeResult( result );
if( sname->name_syms == NULL ) {
TYPE type = sname->name_type->sym_type;
if( TypeDefined( type ) ) {
TYPE dump_type;
dump_type = StructType( type );
if( dump_type != NULL ) {
DumpObjectModelClass( dump_type );
} else {
dump_type = EnumType( type );
if( dump_type != NULL ) {
DumpObjectModelEnum( dump_type );
} else {
CErr2p( ERR_DUMP_OBJ_MODEL, Buffer );
}
}
} else {
CErr2p( ERR_DUMP_OBJ_MODEL, Buffer );
}
} else {
CErr2p( ERR_DUMP_OBJ_MODEL, Buffer );
}
}
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;
}
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 );
}
void PragAux( // #PRAGMA AUX ...
void )
{
struct {
unsigned f_call : 1;
unsigned f_loadds : 1;
unsigned f_rdosdev: 1;
unsigned f_export : 1;
unsigned f_parm : 1;
unsigned f_value : 1;
unsigned f_modify : 1;
unsigned f_frame : 1;
unsigned uses_auto: 1;
} have;
if( !GetAliasInfo() ) return;
CurrEntry = NULL;
if( !IS_ID_OR_KEYWORD( CurToken ) ) return;
SetCurrInfo();
NextToken();
AuxCopy( CurrInfo, CurrAlias );
PragObjNameInfo();
have.f_call = 0;
have.f_loadds = 0;
have.f_rdosdev = 0;
have.f_export = 0;
have.f_parm = 0;
have.f_value = 0;
have.f_modify = 0;
have.f_frame = 0;
have.uses_auto = 0;
for( ;; ) {
if( !have.f_call && CurToken == T_EQUAL ) {
have.uses_auto = GetByteSeq();
have.f_call = 1;
} else if( !have.f_call && PragRecog( "far" ) ) {
CurrInfo->cclass |= FAR_CALL;
have.f_call = 1;
} else if( !have.f_call && PragRecog( "near" ) ) {
CurrInfo->cclass &= ~FAR_CALL;
have.f_call = 1;
} else if( !have.f_loadds && PragRecog( "loadds" ) ) {
CurrInfo->cclass |= LOAD_DS_ON_ENTRY;
have.f_loadds = 1;
} else if( !have.f_rdosdev && PragRecog( "rdosdev" ) ) {
CurrInfo->cclass |= LOAD_RDOSDEV_ON_ENTRY;
have.f_rdosdev = 1;
} else if( !have.f_export && PragRecog( "export" ) ) {
CurrInfo->cclass |= DLL_EXPORT;
have.f_export = 1;
} else if( !have.f_parm && PragRecog( "parm" ) ) {
GetParmInfo();
have.f_parm = 1;
} else if( !have.f_value && PragRecog( "value" ) ) {
GetRetInfo();
have.f_value = 1;
} else if( !have.f_value && PragRecog( "aborts" ) ) {
CurrInfo->cclass |= SUICIDAL;
have.f_value = 1;
} else if( !have.f_modify && PragRecog( "modify" ) ) {
GetSaveInfo();
have.f_modify = 1;
} else if( !have.f_frame && PragRecog( "frame" ) ) {
CurrInfo->cclass |= GENERATE_STACK_FRAME;
have.f_frame = 1;
} else {
break;
}
}
if( have.uses_auto ) {
AsmSysUsesAuto();
}
PragEnding( TRUE );
}
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;
}
