示例#1
0
static void defEmu( void )
{
    if( GET_FPU_EMU( CpuSwitches ) ) {
        DefSwitchMacro( "FPI" );
    } else {
        DefSwitchMacro( "FPI87" );
    }
}
示例#2
0
void MacroDefsSysind            // SYSTEM-INDEPENDENT MACRO DEFINITIONS
    ( void )
{
#ifdef OPT_BR
    if( BrinfActive() ) {
        DefSwitchMacro( "FBI" );
    } else {
        BrinfMacroRelease();
    }
#endif
}
示例#3
0
void MiscMacroDefs(             // PREDEFINE MISCELLANEOUS MACROS
    void )
{
    if( CompFlags.inline_intrinsics ) {
        // this is the only place 'inline_intrinsics' is checked
        // the mechanism works as follows:
        // (1) user sets -ox or -oi
        // (2) macro __INLINE_FUNCTIONS__ is defined
        // (3) user includes <header.h>
        // (4) various prototypes are marked as "intrinsic"
        // (5) fns marked 'intrinsic' will be looked up in code burst tables
        // (6) code for fn will be generated inline
        defineStringMacro( "__INLINE_FUNCTIONS__" );
    }
    if( !CompFlags.extensions_enabled ) {
        defineStringMacro( "NO_EXT_KEYS" );
    }
    if( CompFlags.oldmacros_enabled ) {
        defineKeywordMacros();
    }
    defineStringMacro( "_WCHAR_T_DEFINED" );
    defineStringMacro( "_STDWCHAR_T_DEFINED" );
    if( CompFlags.signed_char ) {
        defineStringMacro( "__CHAR_SIGNED__" );              /* 20-apr-90 */
    }
    if( CompFlags.excs_enabled ) {
        defineStringMacro( "_CPPUNWIND" );
    }
    if( CompFlags.rtti_enabled ) {
        defineStringMacro( "_CPPRTTI" );
    }
    defineFeatureMacros();
    if( !CompFlags.no_alternative_tokens ) {
        DefineAlternativeTokens();
    }
    PreDefineStringMacro( "__WATCOMC__=" _MACROSTR( _BLDVER ) );
    PreDefineStringMacro( "__WATCOM_CPLUSPLUS__=" _MACROSTR( _BLDVER ) );
    // #if __WATCOM_REVISION__ >= 8
    PreDefineStringMacro( "__WATCOM_REVISION__=8" );
    if( !PragToggle.check_stack ) {
        DefSwitchMacro( "S" );
    }
    RingNameFree( &undef_names );
}
示例#4
0
static void macroDefs( void )
{
    if( TargetSwitches & I_MATH_INLINE ) {
        DefSwitchMacro( "OM" );
    }
    switch( TargetSwitches & (BIG_DATA|BIG_CODE|CHEAP_POINTER|FLAT_MODEL) ) {
    case CHEAP_POINTER:
        DefSwitchMacro( "MS" );
        break;
    case BIG_CODE|CHEAP_POINTER:
        DefSwitchMacro( "MM" );
        break;
    case BIG_DATA|CHEAP_POINTER:
        DefSwitchMacro( "MC" );
        break;
    case BIG_CODE|BIG_DATA|CHEAP_POINTER:
        DefSwitchMacro( "ML" );
        break;
    case BIG_CODE|BIG_DATA:
        DefSwitchMacro( "MH" );
        break;
    case FLAT_MODEL|CHEAP_POINTER:
        DefSwitchMacro( "MF" );
        break;
    }
    if( TargetSwitches & FLOATING_FS ) {
        DefSwitchMacro( "ZFF" );
    } else {
        DefSwitchMacro( "ZFP" );
    }
    if( TargetSwitches & FLOATING_GS ) {
        DefSwitchMacro( "ZGF" );
    } else {
        DefSwitchMacro( "ZGP" );
    }
    if( TargetSwitches & FLOATING_DS ) {
        DefSwitchMacro( "ZDF" );
    } else {
        DefSwitchMacro( "ZDP" );
    }
    if( TargetSwitches & FLOATING_SS ) {
        DefSwitchMacro( "ZU" );
    }
    if( TargetSwitches & INDEXED_GLOBALS ) {
        DefSwitchMacro( "XGV" );
    }
    if( TargetSwitches & WINDOWS ) {
        DefSwitchMacro( "ZW" );
    }
    if( TargetSwitches & SMART_WINDOWS ) {
        DefSwitchMacro( "ZWS" );
    }
    if( TargetSwitches & NO_CALL_RET_TRANSFORM ) {
        DefSwitchMacro( "OC" );
    }
    if( TargetSwitches & NEED_STACK_FRAME ) {
        DefSwitchMacro( "OF" );
    }
    if( GenSwitches & NO_OPTIMIZATION ) {
        DefSwitchMacro( "OD" );
    }
    if( GenSwitches & RELAX_ALIAS ) {
        DefSwitchMacro( "OA" );
    }
    if( GenSwitches & BRANCH_PREDICTION ) {
        DefSwitchMacro( "OB" );
    }
    if( GenSwitches & LOOP_OPTIMIZATION ) {
        DefSwitchMacro( "OL" );
    }
    if( GenSwitches & INS_SCHEDULING ) {
        DefSwitchMacro( "OR" );
    }
    if( GenSwitches & FPU_ROUNDING_INLINE ) {
        DefSwitchMacro( "ZRI" );
    }
    if( GenSwitches & FPU_ROUNDING_OMIT ) {
        DefSwitchMacro( "ZRO" );
    }
    if( TargetSwitches & GEN_FWAIT_386 ) {
        DefSwitchMacro( "ZFW" );
    }
    if( CompFlags.signed_char ) {
        DefSwitchMacro( "J" );
    }
    if( CompFlags.use_pcheaders ) {
        DefSwitchMacro( "FH" );
    }
    if( CompFlags.no_pch_warnings ) {
        DefSwitchMacro( "FHQ" );
    }
    if( CompFlags.inline_intrinsics ) {
        DefSwitchMacro( "OI" );
    }
    if( CompFlags.zu_switch_used ) {
        DefSwitchMacro( "ZU" );
    }
    if( CompFlags.unique_functions ) {
        DefSwitchMacro( "OU" );
    }
#if _CPU == 386
    if( CompFlags.register_conventions ) {
        DefSwitchMacro( "3R" );
    } else {
        DefSwitchMacro( "3S" );
    }
#endif
    if( CompFlags.emit_names ) {
        DefSwitchMacro( "EN" );
    }
    if( CompFlags.save_restore_segregs ) {
        DefSwitchMacro( "R" );
    }
    if( CompFlags.zc_switch_used ) {
        DefSwitchMacro( "ZC" );
    }
    if( CompFlags.use_unicode ) {
        DefSwitchMacro( "ZK" );
    }
    if( CompFlags.sg_switch_used ) {
        DefSwitchMacro( "SG" );
    }
    if( CompFlags.st_switch_used ) {
        DefSwitchMacro( "ST" );
    }
    if( CompFlags.bm_switch_used ) {
        PreDefineStringMacro( "_MT" );
        DefSwitchMacro( "BM" );
    }
    if( CompFlags.bd_switch_used ) {
        DefSwitchMacro( "BD" );
    }
    if( CompFlags.br_switch_used ) {
        PreDefineStringMacro( "_DLL" );
        DefSwitchMacro( "BR" );
    }
    if( CompFlags.bw_switch_used ) {
        DefSwitchMacro( "BW" );
    }
    if( CompFlags.zm_switch_used ) {
        DefSwitchMacro( "ZM" );
    }
    if( CompFlags.ep_switch_used ) {
        DefSwitchMacro( "EP" );
    }
    if( CompFlags.ee_switch_used ) {
        DefSwitchMacro( "EE" );
    }
    switch( CompInfo.dt_method_speced ) {
      case DTM_DIRECT :
        DefSwitchMacro( "XDT" );
        DefSwitchMacro( "XD" );
        break;
      case DTM_DIRECT_SMALL :
        DefSwitchMacro( "XDS" );
        break;
      case DTM_TABLE :
        DefSwitchMacro( "XS" );
        break;
      case DTM_DIRECT_TABLE :
        DefSwitchMacro( "XST" );
        break;
      case DTM_TABLE_SMALL :
        DefSwitchMacro( "XSS" );
        break;
      DbgDefault( "macroDefs -- invalid exception switch" );
    }
    switch( GET_CPU( CpuSwitches ) ) {
    case CPU_86:
        DefSwitchMacro( "0" );
        break;
    case CPU_186:
        DefSwitchMacro( "1" );
        break;
    case CPU_286:
        DefSwitchMacro( "2" );
        break;
    case CPU_386:
        DefSwitchMacro( "3" );
        break;
    case CPU_486:
        DefSwitchMacro( "4" );
        break;
    case CPU_586:
        DefSwitchMacro( "5" );
        break;
    case CPU_686:
        DefSwitchMacro( "6" );
        break;
    }
    switch( GET_FPU_LEVEL( CpuSwitches ) ) {
    case FPU_NONE:
        CompFlags.op_switch_used = 0;
        DefSwitchMacro( "FPC" );
        break;
    case FPU_87:
        DefSwitchMacro( "FP287" );
        defEmu();
        break;
    case FPU_387:
        DefSwitchMacro( "FP387" );
        defEmu();
        break;
    case FPU_586:
        DefSwitchMacro( "FP5" );
        defEmu();
        break;
    case FPU_686:
        DefSwitchMacro( "FP6" );
        defEmu();
        break;
    }
    if( CompFlags.op_switch_used ) {
        DefSwitchMacro( "OP" );
    }
    PreDefineStringMacro( "_INTEGRAL_MAX_BITS=64" );
#if _CPU == 386
    PreDefineStringMacro( "_STDCALL_SUPPORTED" );
#endif
    if( CompFlags.oldmacros_enabled ) {
#if _CPU == 8086
        if( TargetSwitches & WINDOWS ) {
            PreDefineStringMacro( "SOMLINK=__cdecl" );
            PreDefineStringMacro( "SOMDLINK=__far" );
        }
#else
        PreDefineStringMacro( "SOMLINK=_Syscall" );
        PreDefineStringMacro( "SOMDLINK=_Syscall" );
#endif
    }
}
示例#5
0
static void analyseAnyTargetOptions( OPT_STORAGE *data )
{
    // quickly do the quiet option so the banner can be printed
    if( data->q || data->zq ) {
        CompFlags.quiet_mode = 1;
    }
    switch( data->char_set ) {
    case OPT_char_set_zku:
        CompFlags.use_unicode = 1;
        loadUnicodeTable( data->zku_value );
        break;
    case OPT_char_set_zk0u:
        CompFlags.jis_to_unicode = 1;
        /* fall through */
    case OPT_char_set_zk0:
        SetDBChar( 0 );
        break;
    case OPT_char_set_zk1:
        SetDBChar( 1 );
        break;
    case OPT_char_set_zk2:
        SetDBChar( 2 );
        break;
    case OPT_char_set_zkl:
        SetDBChar( -1 );
        break;
    }
    switch( data->exc_level ) {
    case OPT_exc_level_xs:
        CompFlags.excs_enabled = TRUE;
        CompInfo.dt_method_speced = DTM_TABLE;
        break;
    case OPT_exc_level_xst:
        CompFlags.excs_enabled = TRUE;
        CompInfo.dt_method_speced = DTM_DIRECT_TABLE;
        break;
    case OPT_exc_level_xss:
        CompFlags.excs_enabled = TRUE;
        CompInfo.dt_method_speced = DTM_TABLE_SMALL;
        break;
    case OPT_exc_level_xds:
        CompFlags.excs_enabled = FALSE;
        CompInfo.dt_method_speced = DTM_DIRECT_SMALL;
        break;
    case OPT_exc_level_xd:
    case OPT_exc_level_xdt:
    default:
        CompFlags.excs_enabled = FALSE;
        CompInfo.dt_method_speced = DTM_DIRECT;
        break;
    }
    switch( data->warn_level ) {
    case OPT_warn_level_w:
        WngLevel = data->w_value;
        break;
    case OPT_warn_level_wx:
        WngLevel = WLEVEL_WX;
        break;
    default:
        WngLevel = WLEVEL_DEFAULT;
        break;
    }
    switch( data->file_83 ) {
    case OPT_file_83_fx:
        CompFlags.check_truncated_fnames = 0;
        break;
    case OPT_file_83_ft:
    default:
        CompFlags.check_truncated_fnames = 1;
        break;
    }
    switch( data->opt_level ) {
    case OPT_opt_level_ox:  /* -ox => -obmiler -s */
        GenSwitches &= ~ NO_OPTIMIZATION;
        GenSwitches |= BRANCH_PREDICTION;       // -ob
        GenSwitches |= LOOP_OPTIMIZATION;       // -ol
        GenSwitches |= INS_SCHEDULING;          // -or
        CmdSysSetMaxOptimization();             // -om
        CompFlags.inline_intrinsics = 1;        // -oi
#if 0   // Disabled - introduces too many problems which no one is ready to fix
        if( ! data->oe ) {
            data->oe = 1;                       // -oe
            // keep in sync with options.gml
            data->oe_value = 100;
        }
#endif
        PragToggle.check_stack = 0;             // -s
        break;
    case OPT_opt_level_od:
        GenSwitches |= NO_OPTIMIZATION;
        break;
    }
    switch( data->opt_size_time ) {
    case OPT_opt_size_time_ot:
        OptSize = 0;
        GenSwitches &= ~ NO_OPTIMIZATION;
        break;
    case OPT_opt_size_time_os:
        OptSize = 100;
        GenSwitches &= ~ NO_OPTIMIZATION;
        break;
    default:
        OptSize = 50;
        break;
    }
    switch( data->iso ) {
    case OPT_iso_za:
        CompFlags.extensions_enabled = 0;
        CompFlags.oldmacros_enabled = 0;
        CompFlags.unique_functions = 1;
        break;
    case OPT_iso_ze:
    default:
        CompFlags.extensions_enabled = 1;
        CompFlags.oldmacros_enabled = 1;
        break;
    }
    if( data->zam ) {
        CompFlags.oldmacros_enabled = 0;
    }
    // following must precede processing of data->oe
    switch( data->debug_info ) {
    case OPT_debug_info_d3s:
        CompFlags.static_inline_fns = 1;
        /* fall through */
    case OPT_debug_info_d3i:
        CompFlags.inline_functions = 0;
        /* fall through */
    case OPT_debug_info_d3:
        // this flag may be turned on when PCHs are written if we will be
        // optimizing the writing of the debugging info by referring back
        // to the info in another module
        CompFlags.all_debug_type_names = 1;
        GenSwitches |= NUMBERS | DBG_TYPES | DBG_LOCALS;
        if( debugOptionAfterOptOption( data ) ) {
            GenSwitches |= NO_OPTIMIZATION;
        }
        data->oe = 0;
        break;
    case OPT_debug_info_d2s:
        CompFlags.static_inline_fns = 1;
        /* fall through */
    case OPT_debug_info_d2i:
        CompFlags.inline_functions = 0;
        /* fall through */
    case OPT_debug_info_d2:
        GenSwitches |= NUMBERS | DBG_TYPES | DBG_LOCALS;
        if( debugOptionAfterOptOption( data ) ) {
            GenSwitches |= NO_OPTIMIZATION;
        }
        data->oe = 0;
        break;
    case OPT_debug_info_d2t:
        CompFlags.no_debug_type_names = 1;
        GenSwitches |= NUMBERS | DBG_TYPES | DBG_LOCALS;
        if( debugOptionAfterOptOption( data ) ) {
            GenSwitches |= NO_OPTIMIZATION;
        }
        data->oe = 0;
        break;
    case OPT_debug_info_d1:
        GenSwitches |= NUMBERS;
        break;
    case OPT_debug_info_d0:
        break;
    }
    switch( data->enum_size ) {
    case OPT_enum_size_ei:
        CompFlags.make_enums_an_int = 1;
        CompFlags.original_enum_setting = 1;
        break;
    case OPT_enum_size_em:
        CompFlags.make_enums_an_int = 0;
        CompFlags.original_enum_setting = 0;
        break;
    /* default set in CmdSysInit() */
    }
    if( data->bd ) {
        CompFlags.bd_switch_used = 1;
        GenSwitches |= DLL_RESIDENT_CODE;
    }
    if( data->bm ) {
        CompFlags.bm_switch_used = 1;
    }
    if( data->bw ) {
        CompFlags.bw_switch_used = 1;
    }
    if( data->bc ) {
        CompFlags.bc_switch_used = 1;
    }
    if( data->bg ) {
        CompFlags.bg_switch_used = 1;
    }
    if( data->db ) {
        CompFlags.emit_browser_info = 1;
#if 0
        if( data->fhd ) {
            CompFlags.pch_debug_info_opt = 1;
        }
#endif
    }
    if( data->ee ) {
        CompFlags.ee_switch_used = 1;
    }
    if( data->ef ) {
        CompFlags.error_use_full = 1;
    }
    if( data->ep ) {
        CompFlags.ep_switch_used = 1;
        ProEpiDataSize = data->ep_value;
    }
    if( data->en ) {
        CompFlags.emit_names = 1;
    }
    if( data->er ) {
        CompFlags.no_error_sym_injection = 1;
    }
    if( data->ew ) {
        CompFlags.ew_switch_used = 1;
    }
    if( data->e ) {
        ErrLimit = data->e_value;
    } else {
        ErrLimit = 20;
    }
    if( data->fhd ) {
        CompFlags.use_pcheaders = TRUE;
    }
    if( data->fhr_exclamation ) {
        CompFlags.pch_min_check = TRUE;
        data->fhr = TRUE;
    }
    if( data->fhr ) {
        CompFlags.use_pcheaders = TRUE;
        CompFlags.fhr_switch_used = TRUE;
    }
    if( data->fhw ) {
        CompFlags.use_pcheaders = TRUE;
        CompFlags.fhw_switch_used = TRUE;
    }
    if( data->fhwe ) {
        CompFlags.use_pcheaders = TRUE;
        CompFlags.fhwe_switch_used = TRUE;
    }
    if( data->fh || data->fhq ) {
        char *fh_name;
        char *fhq_name;
        char *p;
        if( data->fhq ) {
            CompFlags.no_pch_warnings = TRUE;
        }
        CompFlags.use_pcheaders = TRUE;
        fh_name = reduceToOneString( &(data->fh_value) );
        fhq_name = reduceToOneString( &(data->fhq_value) );
        if( fh_name != NULL ) {
            p = fh_name;
            if( fhq_name != NULL ) {
                /* use the latest file-name specified */
                if( data->fh_timestamp > data->fhq_timestamp ) {
                    CMemFree( fhq_name );
                } else {
                    CMemFree( fh_name );
                    p = fhq_name;
                }
            }
        } else {
            p = fhq_name;
        }
        PCHSetFileName( p );
    }
    if( data->fi ) {
        SetStringOption( &ForceInclude, &(data->fi_value) );
    }
    if( data->ad ) {
        SetStringOption( &DependFileName, &(data->ad_value) );
        CompFlags.generate_auto_depend = 1;
    }
    if( data->adt ) {
        SetStringOption( &TargetFileName, &(data->adt_value) );
        CompFlags.generate_auto_depend = 1;
    }
    if( data->add ) {
        SetStringOption( &SrcDepFileName, &(data->add_value) );
        CompFlags.generate_auto_depend = 1;
    }
    if( data->adhp ) {
        SetStringOption( &DependHeaderPath, &(data->adhp_value) );
        CompFlags.generate_auto_depend = 1;
    }
    if( data->adfs ) {
        ForceSlash = '/';
    }
    if( data->adbs ) {
        ForceSlash = '\\';
    }
    if( data->fo ) {
        SetStringOption( &ObjectFileName, &(data->fo_value) );
        CompFlags.cpp_output_to_file = 1;   /* in case '-p' option */
    }
    if( data->fr ) {
        SetStringOption( &ErrorFileName, &(data->fr_value) );
    }
    if( data->i ) {
        OPT_STRING *s;
        reverseList( &(data->i_value) );
        for( s = data->i_value; s != NULL; s = s->next ) {
            HFileAppend( s->data );
        }
    }
    if( data->jw ) {
        data->j = TRUE;
        CompFlags.plain_char_promotion = 1;
    }
    if( data->j ) {
        PTypeSignedChar();
        CompFlags.signed_char = 1;
    }
    if( data->k ) {
        CompFlags.batch_file_continue = 1;
    }
    if( data->oa ) {
        GenSwitches |= RELAX_ALIAS;
    }
    if( data->ob ) {
        GenSwitches |= BRANCH_PREDICTION;
    }
    // following must follow processing of debug options
    if( data->oe ) {
        CgBackSetOeSize( data->oe_value );
    }
    if( data->oh ) {
        GenSwitches |= SUPER_OPTIMAL;
    }
    if( data->oi ) {
        CompFlags.inline_intrinsics = 1;
    }
    if( data->oi_plus ) {
        CgBackSetInlineDepth( MAX_INLINE_DEPTH );
#if 0
        // 98/01/08 -- this is disabled because it blows the code up too much
        //             and slows compiles down over much (jww)
        CgBackSetInlineRecursion( TRUE );
#endif
    }
    if( data->ok ) {
        GenSwitches |= FLOW_REG_SAVES;
    }
    if( data->ol ) {
        GenSwitches |= LOOP_OPTIMIZATION;
    }
    if( data->ol_plus ) {
        GenSwitches |= LOOP_UNROLLING;
    }
    if( data->on ) {
        GenSwitches |= FP_UNSTABLE_OPTIMIZATION;
    }
    if( data->oo ) {
        GenSwitches &= ~ MEMORY_LOW_FAILS;
    }
    if( data->op ) {
        CompFlags.op_switch_used = 1;
    }
    if( data->or ) {
        GenSwitches |= INS_SCHEDULING;
    }
    if( data->ou ) {
        CompFlags.unique_functions = 1;
    }
    if( data->oz ) {
        GenSwitches |= NULL_DEREF_OK;
    }
    if( data->pil ) {
        CompFlags.cpp_ignore_line = 1;
    }
    if( data->p ) {
        CompFlags.cpp_output_requested = 1;
    }
    if( data->pc ) {
        CompFlags.cpp_output_requested = 1;
        CompFlags.keep_comments = 1;
        CompFlags.comments_wanted = 1;
    }
    if( data->pe ) {
        CompFlags.cpp_output_requested = 1;
        CompFlags.encrypt_preproc_output = 1;
    }
    if( data->pj ) {
        data->pl = TRUE;
        CompFlags.line_comments = 1;
    }
    if( data->pl ) {
        CompFlags.cpp_output_requested = 1;
        CompFlags.cpp_line_wanted = 1;
    }
    if( data->pw ) {
        CompFlags.cpp_output_requested = 1;
        PpSetWidth( data->pw_value );
    } else {
        // #line directives get screwed by wrapped lines but we don't want
        // to interfere with a user's setting of the width
        if( data->pl ) {
            PpSetWidth( 0 );
        }
    }
    if( CompFlags.cpp_output_requested ) {
        CompFlags.cpp_output = 1;
        CompFlags.quiet_mode = 1;
    }
    if( data->p_sharp ) {
        PreProcChar = (char)data->p_sharp_value;
    }
    if( data->rod ) {
        OPT_STRING *s;
        for( s = data->rod_value; s != NULL; s = s->next ) {
            SrcFileReadOnlyDir( s->data );
        }
    }
    if( data->s ) {
        PragToggle.check_stack = 0;
    }
    if( data->t ) {
        SrcFileSetTab( data->t_value );
    }
    if( data->v ) {
        CompFlags.dump_prototypes = 1;
    }
    if( data->wcd ) {
        OPT_NUMBER *n;
        for( n = data->wcd_value; n != NULL; n = n->next ) {
            WarnChangeLevel( WLEVEL_DISABLE, n->number );
        }
    }
    if( data->wce ) {
        OPT_NUMBER *n;
        for( n = data->wce_value; n != NULL; n = n->next ) {
            WarnChangeLevel( WLEVEL_ENABLE, n->number );
        }
    }
    if( data->we ) {
        CompFlags.warnings_cause_bad_exit = 1;
    }
    if( data->x ) {
        CompFlags.cpp_ignore_env = 1;
    }
    if( data->xbnm ) {
        CompFlags.fixed_name_mangling = 1;
    }
    if( data->xbsa ) {
        CompFlags.dont_align_segs = 1;
    }
    if( data->xbov1 ) {
        CompFlags.overload_13332 = 1;
    }
    if( data->xcmb ) {
        CompFlags.modifier_bind_compatibility = 1;
    }
    if( data->xcpi ) {
        CompFlags.prototype_instantiate = 1;
    }
    if( data->xr ) {
        CompFlags.rtti_enabled = 1;
    }
    if( data->xto ) {
        CompFlags.obfuscate_typesig_names = 1;
    }
    if( data->xx ) {
        CompFlags.ignore_default_dirs = 1;
    }
    if( data->zat ) {
        CompFlags.no_alternative_tokens = 1;
    }
    if( data->za0x ) {
        CompFlags.enable_std0x = 1;
    }
    if( data->zf ) {
        CompFlags.use_old_for_scope = 1;
    }
    if( data->zg ) {
        CompFlags.use_base_types = 1;
    }
    if( data->zld ) {
        CompFlags.emit_dependencies = 0;
    }
    if( data->zlf ) {
        CompFlags.emit_all_default_libs = 1;
    }
    if( data->zls ) {
        CompFlags.emit_targimp_symbols = 0;
    }
    if( data->fzh ) {   /* Define the switch macros for STLPort */
        CompFlags.dont_autogen_ext_inc = 1;
        DefSwitchMacro( "FZH" );
    }
    if( data->fzs ) {   /* Define the switch macros for STLPort */
        CompFlags.dont_autogen_ext_src = 1;
        DefSwitchMacro( "FZS" );
    }
    if( data->zl ) {
        CompFlags.emit_library_names = 0;
    }
    if( data->zp ) {
        PackAmount = data->zp_value;
        GblPackAmount = PackAmount;
    }
    if( data->zpw ) {
        CompFlags.warn_about_padding = 1;
    }
    if( data->zs ) {
        CompFlags.check_syntax = 1;
    }
    if( data->zv ) {
#if COMP_CFG_COFF == 0
        CompFlags.virtual_stripping = TRUE;
#endif
    }
    if( data->na ) {
        CompFlags.disable_ialias = 1;
    }
#ifndef NDEBUG
    if( data->tp ) {
        for(;;) {
            OPT_STRING* str = data->tp_value;
            if( NULL == str ) break;
            data->tp_value = str->next;
            strcpy( Buffer, str->data );
            CMemFree( str );
            PragmaSetToggle( TRUE );
        }
    }
    if( data->zi ) {
        CompFlags.extra_stats_wanted = 1;
        // try to prevent distortions caused by debug stuff
        PragDbgToggle.no_mem_cleanup = 1;
    }
#endif
    CBanner();
}