ref: d488fabe62aabd0d42421eb3e423a9308ae1fa13
dir: /setup/SPBLDOPT.i/
/* SPBLDOPT.i Copyright (C) 2007 Paul C. Pratt You can redistribute this file and/or modify it under the terms of version 2 of the GNU General Public License as published by the Free Software Foundation. You should have received a copy of the license along with this file; see the file COPYING. This file is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the license for more details. */ /* program SPecific BuiLD OPTions */ /* option: model */ enum { gbk_mdl_Twig43, gbk_mdl_Twiggy, gbk_mdl_128K, gbk_mdl_512Ke, gbk_mdl_Plus, gbk_mdl_SE, gbk_mdl_SEFDHD, gbk_mdl_Classic, gbk_mdl_PB100, gbk_mdl_II, gbk_mdl_IIx, kNumModels }; LOCALVAR int cur_mdl; LOCALVAR ui3r olv_mdl; LOCALPROC ResetModelOption(void) { cur_mdl = kListOptionAuto; olv_mdl = 0; } LOCALFUNC char * GetModelName(int i) { char *s; switch (i) { case gbk_mdl_Twig43: s = "Twig43"; break; case gbk_mdl_Twiggy: s = "Twiggy"; break; case gbk_mdl_128K: s = "128K"; break; case gbk_mdl_512Ke: s = "512Ke"; break; case gbk_mdl_Plus: s = "Plus"; break; case gbk_mdl_SE: s = "SE"; break; case gbk_mdl_SEFDHD: s = "SEFDHD"; break; case gbk_mdl_Classic: s = "Classic"; break; case gbk_mdl_PB100: s = "PB100"; break; case gbk_mdl_II: s = "II"; break; case gbk_mdl_IIx: s = "IIx"; break; default: s = "(unknown Model)"; break; } return s; } LOCALFUNC tMyErr TryAsModelOptionNot(void) { return FindNamedOption("-m", kNumModels, GetModelName, &cur_mdl, &olv_mdl); } #define dfo_mdl() gbk_mdl_Plus LOCALVAR blnr cur_mIIorIIX; LOCALFUNC tMyErr ChooseModel(void) { if (kListOptionAuto == cur_mdl) { cur_mdl = dfo_mdl(); } cur_mIIorIIX = (gbk_mdl_II == cur_mdl) || (gbk_mdl_IIx == cur_mdl); #if 0 if (cur_mIIorIIX) { if (gbk_cpufam_68k == gbo_cpufam) { err = ReportParseFailure( "Mac II emulation is not supported on Macintosh 680x0"); } } #endif return kMyErr_noErr; } LOCALPROC WrtOptModelOption(void) { WrtOptNamedOption("-m", GetModelName, cur_mdl, dfo_mdl()); } /* option: horizontal resolution */ LOCALVAR uimr cur_hres; LOCALVAR ui3r olv_hres; LOCALPROC ResetHResOption(void) { olv_hres = 0; } LOCALFUNC tMyErr TryAsHResOptionNot(void) { return NumberTryAsOptionNot("-hres", (long *)&cur_hres, &olv_hres); } LOCALFUNC uimr dfo_hres(void) { uimr v; if (cur_mIIorIIX) { v = 640; } else if (gbk_mdl_PB100 == cur_mdl) { v = 640; } else { v = 512; } return v; } LOCALFUNC tMyErr ChooseHRes(void) { tMyErr err; MyPStr t; MyPStr s; if (0 == olv_hres) { cur_hres = dfo_hres(); err = kMyErr_noErr; } else { if ((cur_hres & 0x1F) != 0) { PStrFromCStr(t, "-hres must be a multiple of 32." " The next lowest multiple is "); PStrFromUimr(cur_hres & ~ 0x1F, s); PStrAppend(t, s); err = ReportParseFailPStr(t); } else if (cur_hres < 128) { err = ReportParseFailure("-hres must be >= 128"); } else if (cur_hres >= (uimr)32 * 1024) { err = ReportParseFailure("-hres must be < 32k"); } else { err = kMyErr_noErr; } } return err; } LOCALPROC WrtOptHResOption(void) { WrtOptNumberOption("-hres", cur_hres, dfo_hres()); } /* option: vertical resolution */ LOCALVAR uimr cur_vres; LOCALVAR ui3r olv_vres; LOCALPROC ResetVResOption(void) { olv_vres = 0; } LOCALFUNC tMyErr TryAsVResOptionNot(void) { return NumberTryAsOptionNot("-vres", (long *)&cur_vres, &olv_vres); } LOCALFUNC uimr dfo_vres(void) { uimr v; if (cur_mIIorIIX) { v = 480; } else if (gbk_mdl_PB100 == cur_mdl) { v = 400; } else { v = 342; } return v; } LOCALFUNC tMyErr ChooseVRes(void) { tMyErr err; if (0 == olv_vres) { cur_vres = dfo_vres(); err = kMyErr_noErr; } else { if (cur_vres < 128) { err = ReportParseFailure("-vres must be >= 128"); } else if (cur_vres >= (uimr)32 * 1024) { err = ReportParseFailure("-vres must be < 32k"); } else { err = kMyErr_noErr; } } return err; } LOCALPROC WrtOptVResOption(void) { WrtOptNumberOption("-vres", cur_vres, dfo_vres()); } /* option: screen depth */ LOCALVAR uimr cur_ScrnDpth; LOCALVAR ui3r olv_ScrnDpth; LOCALPROC ResetScrnDpthOption(void) { olv_ScrnDpth = 0; } LOCALFUNC tMyErr TryAsScrnDpthOptionNot(void) { return NumberTryAsOptionNot("-depth", (long *)&cur_ScrnDpth, &olv_ScrnDpth); } LOCALFUNC uimr dfo_ScrnDpth(void) { uimr v; if (cur_mIIorIIX) { v = 3; } else { v = 0; } return v; } LOCALFUNC tMyErr ChooseScrnDpth(void) { tMyErr err; err = kMyErr_noErr; if (0 == olv_ScrnDpth) { cur_ScrnDpth = dfo_ScrnDpth(); } else { if (cur_mIIorIIX) { if (cur_ScrnDpth > 5) { err = ReportParseFailure("-depth must be <= 5"); } } else { if (cur_ScrnDpth != 0) { err = ReportParseFailure( "-depth must be 0 for this model"); } } } return err; } LOCALPROC WrtOptScrnDpth(void) { WrtOptNumberOption("-depth", cur_ScrnDpth, dfo_ScrnDpth()); } /* option: Initial FullScreen */ LOCALVAR blnr WantInitFullScreen; LOCALVAR ui3r olv_InitFullScreen; LOCALPROC ResetInitFullScreen(void) { WantInitFullScreen = nanblnr; olv_InitFullScreen = 0; } LOCALFUNC tMyErr TryAsInitFullScreenNot(void) { return BooleanTryAsOptionNot("-fullscreen", &WantInitFullScreen, &olv_InitFullScreen); } LOCALFUNC blnr dfo_InitFullScreen(void) { blnr v; v = gbk_targfam_wnce == gbo_targfam; return v; } LOCALFUNC tMyErr ChooseInitFullScreen(void) { tMyErr err; err = kMyErr_noErr; if (nanblnr == WantInitFullScreen) { WantInitFullScreen = dfo_InitFullScreen(); } else { if (! WantInitFullScreen) { if (gbk_targ_wcar == cur_targ) { err = ReportParseFailure( "-fullscreen 0 is not supported for -t wcar"); } } } return err; } LOCALPROC WrtOptInitFullScreen(void) { WrtOptBooleanOption("-fullscreen", WantInitFullScreen, dfo_InitFullScreen()); } /* option: Variable FullScreen */ LOCALVAR blnr WantVarFullScreen; LOCALVAR ui3r olv_VarFullScreen; LOCALPROC ResetVarFullScreen(void) { WantVarFullScreen = nanblnr; olv_VarFullScreen = 0; } LOCALFUNC tMyErr TryAsVarFullScreenNot(void) { return BooleanTryAsOptionNot("-var-fullscreen", &WantVarFullScreen, &olv_VarFullScreen); } LOCALFUNC blnr dfo_VarFullScreen(void) { blnr v; if ((gbk_apifam_gtk == gbo_apifam) || (gbk_targfam_wnce == gbo_targfam)) { v = falseblnr; } else { v = trueblnr; } return v; } LOCALFUNC tMyErr ChooseVarFullScreen(void) { tMyErr err; err = kMyErr_noErr; if (nanblnr == WantVarFullScreen) { WantVarFullScreen = dfo_VarFullScreen(); } else { if (WantVarFullScreen) { if (gbk_targ_wcar == cur_targ) { err = ReportParseFailure( "-var-fullscreen is not supported for -t wcar"); } } } return err; } LOCALPROC WrtOptVarFullScreen(void) { WrtOptBooleanOption("-var-fullscreen", WantVarFullScreen, dfo_VarFullScreen()); } /* option: magnification factor */ LOCALVAR uimr cur_MagFctr; LOCALVAR ui3r olv_MagFctr; LOCALPROC ResetMagFctrOption(void) { olv_MagFctr = 0; } LOCALFUNC tMyErr TryAsMagFctrOptionNot(void) { return NumberTryAsOptionNot("-mf", (long *)&cur_MagFctr, &olv_MagFctr); } LOCALFUNC uimr dfo_MagFctr(void) { uimr v; if (gbk_apifam_gtk == gbo_apifam) { /* temporary, until implemented */ v = 1; } else { v = 2; } return v; } LOCALFUNC tMyErr ChooseMagFctr(void) { tMyErr err; err = kMyErr_noErr; if (0 == olv_MagFctr) { cur_MagFctr = dfo_MagFctr(); } else { if (cur_MagFctr < 1) { err = ReportParseFailure("-mf must be >= 1"); } } return err; } LOCALPROC WrtOptMagFctrOption(void) { WrtOptNumberOption("-mf", cur_MagFctr, dfo_MagFctr()); } /* option: Initial Magnify */ LOCALVAR blnr WantInitMagnify; LOCALVAR ui3r olv_InitMagnify; LOCALPROC ResetInitMagnify(void) { WantInitMagnify = nanblnr; olv_InitMagnify = 0; } LOCALFUNC tMyErr TryAsInitMagnifyNot(void) { return BooleanTryAsOptionNot("-magnify", &WantInitMagnify, &olv_InitMagnify); } #define dfo_InitMagnify() falseblnr LOCALFUNC tMyErr ChooseInitMagnify(void) { tMyErr err; err = kMyErr_noErr; if (nanblnr == WantInitMagnify) { WantInitMagnify = dfo_InitMagnify(); } else { if (WantInitMagnify && (cur_MagFctr == 1)) { err = ReportParseFailure( "-magnify 1 does not make sense with -mf 1"); } } return err; } LOCALPROC WrtOptInitMagnify(void) { WrtOptBooleanOption("-magnify", WantInitMagnify, dfo_InitMagnify()); } /* option: sound */ LOCALVAR blnr MySoundEnabled; LOCALVAR ui3r olv_SoundEnabled; LOCALPROC ResetSoundOption(void) { MySoundEnabled = nanblnr; olv_SoundEnabled = 0; } LOCALFUNC tMyErr TryAsSoundOptionNot(void) { return BooleanTryAsOptionNot("-sound", &MySoundEnabled, &olv_SoundEnabled); } LOCALFUNC blnr dfo_SoundEnabled(void) { blnr v; v = (gbk_apifam_mac == gbo_apifam) || (gbk_apifam_osx == gbo_apifam) || (gbk_apifam_win == gbo_apifam) || (gbk_apifam_sdl == gbo_apifam) || (gbk_apifam_sd2 == gbo_apifam) || (gbk_apifam_9dr == gbo_apifam) || (gbk_apifam_cco == gbo_apifam) || ((gbk_apifam_xwn == gbo_apifam) && ((gbo_targfam == gbk_targfam_linx) || (gbo_targfam == gbk_targfam_fbsd) || (gbo_targfam == gbk_targfam_nbsd))); return v; } LOCALFUNC tMyErr ChooseSoundEnabled(void) { if (nanblnr == MySoundEnabled) { MySoundEnabled = dfo_SoundEnabled(); } return kMyErr_noErr; } LOCALPROC WrtOptSoundOption(void) { WrtOptBooleanOption("-sound", MySoundEnabled, dfo_SoundEnabled()); } /* option: sound api */ enum { gbk_sndapi_none, gbk_sndapi_alsa, gbk_sndapi_ddsp, kNumSndApiLevels }; LOCALVAR int gbo_sndapi; LOCALVAR ui3r olv_sndapi; LOCALPROC ResetSndApiOption(void) { gbo_sndapi = kListOptionAuto; olv_sndapi = 0; } LOCALFUNC char * GetSndApiName(int i) { char *s; switch (i) { case gbk_sndapi_none: s = "none"; break; case gbk_sndapi_alsa: s = "alsa"; break; case gbk_sndapi_ddsp: s = "ddsp"; break; default: s = "(unknown sound api)"; break; } return s; } LOCALFUNC tMyErr TryAsSndApiOptionNot(void) { return FindNamedOption("-snd-api", kNumSndApiLevels, GetSndApiName, &gbo_sndapi, &olv_sndapi); } LOCALFUNC int dfo_sndapi(void) { int v; if (! MySoundEnabled) { v = gbk_sndapi_none; } else if (gbk_apifam_xwn != gbo_apifam) { v = gbk_sndapi_none; } else if (gbo_targfam == gbk_targfam_linx) { v = gbk_sndapi_alsa; } else { v = gbk_sndapi_ddsp; } return v; } LOCALFUNC tMyErr ChooseSndApiOption(void) { if (kListOptionAuto == gbo_sndapi) { gbo_sndapi = dfo_sndapi(); } return kMyErr_noErr; } LOCALPROC WrtOptSndApiOption(void) { WrtOptNamedOption("-snd-api", GetSndApiName, gbo_sndapi, dfo_sndapi()); } /* option: sound sample size */ LOCALVAR uimr cur_SoundSampSz; LOCALVAR ui3r olv_SoundSampSz; LOCALPROC ResetSoundSampSzOption(void) { olv_SoundSampSz = 0; } LOCALFUNC tMyErr TryAsSoundSampSzOptionNot(void) { return NumberTryAsOptionNot("-sss", (long *)&cur_SoundSampSz, &olv_SoundSampSz); } LOCALFUNC uimr dfo_SoundSampSz(void) { uimr v; if (gbk_sndapi_ddsp == gbo_sndapi) { v = 4; } else { v = 3; } return v; } LOCALFUNC tMyErr ChooseSoundSampSz(void) { tMyErr err; err = kMyErr_noErr; if (0 == olv_SoundSampSz) { cur_SoundSampSz = dfo_SoundSampSz(); } else { if ((cur_SoundSampSz < 3) || (cur_SoundSampSz > 4)) { err = ReportParseFailure( "-sss must be 3 or 4"); } } return err; } LOCALPROC WrtOptSoundSampSzOption(void) { WrtOptNumberOption("-sss", cur_SoundSampSz, dfo_SoundSampSz()); } /* option: number of drives */ LOCALVAR uimr cur_numdrives; LOCALVAR ui3r olv_numdrives; LOCALPROC ResetNumDrivesOption(void) { olv_numdrives = 0; } LOCALFUNC tMyErr TryAsNumDrivesOptionNot(void) { return NumberTryAsOptionNot("-drives", (long *)&cur_numdrives, &olv_numdrives); } LOCALFUNC uimr dfo_numdrives(void) { uimr v; if (cur_mdl < gbk_mdl_512Ke) { v = 2; } else { v = 6; } return v; } LOCALFUNC tMyErr ChooseNumDrives(void) { tMyErr err; err = kMyErr_noErr; if (0 == olv_numdrives) { cur_numdrives = dfo_numdrives(); } else { if ((cur_numdrives <= 0) || (cur_numdrives > 32)) { err = ReportParseFailure( "-drives must be a number between 1 and 32"); } } return err; } LOCALPROC WrtOptNumDrivesOption(void) { WrtOptNumberOption("-drives", cur_numdrives, dfo_numdrives()); } /* option: disk driver - support tags */ LOCALVAR blnr SonySupportTags; LOCALVAR ui3r olv_SonySupportTags; LOCALPROC ResetSonySupportTags(void) { SonySupportTags = nanblnr; olv_SonySupportTags = 0; } LOCALFUNC tMyErr TryAsSonySupportTagsNot(void) { return BooleanTryAsOptionNot("-sony-tag", &SonySupportTags, &olv_SonySupportTags); } #define dfo_SonySupportTags() falseblnr LOCALFUNC tMyErr ChooseSonySupportTags(void) { if (nanblnr == SonySupportTags) { SonySupportTags = dfo_SonySupportTags(); } return kMyErr_noErr; } LOCALPROC WrtOptSonySupportTags(void) { WrtOptBooleanOption("-sony-tag", SonySupportTags, dfo_SonySupportTags()); } /* option: disk driver - calculate checksums */ LOCALVAR blnr SonyWantChecksumsUpdated; LOCALVAR ui3r olv_SonyWantChecksumsUpdated; LOCALPROC ResetSonyWantChecksumsUpdated(void) { SonyWantChecksumsUpdated = nanblnr; olv_SonyWantChecksumsUpdated = 0; } LOCALFUNC tMyErr TryAsSonyWantChecksumsUpdatedNot(void) { return BooleanTryAsOptionNot("-sony-sum", &SonyWantChecksumsUpdated, &olv_SonyWantChecksumsUpdated); } #define dfo_SonyWantChecksumsUpdated() falseblnr LOCALFUNC tMyErr ChooseSonyWantChecksumsUpdated(void) { if (nanblnr == SonyWantChecksumsUpdated) { SonyWantChecksumsUpdated = dfo_SonyWantChecksumsUpdated(); } return kMyErr_noErr; } LOCALPROC WrtOptSonyWantChecksumsUpdated(void) { WrtOptBooleanOption("-sony-sum", SonyWantChecksumsUpdated, dfo_SonyWantChecksumsUpdated()); } /* option: disk driver - support disk copy 4.2 format */ LOCALVAR blnr SonySupportDC42; LOCALVAR ui3r olv_SonySupportDC42; LOCALPROC ResetSonySupportDC42(void) { SonySupportDC42 = nanblnr; olv_SonySupportDC42 = 0; } LOCALFUNC tMyErr TryAsSonySupportDC42Not(void) { return BooleanTryAsOptionNot("-sony-dc42", &SonySupportDC42, &olv_SonySupportDC42); } #define dfo_SonySupportDC42() trueblnr LOCALFUNC tMyErr ChooseSonySupportDC42(void) { if (nanblnr == SonySupportDC42) { SonySupportDC42 = dfo_SonySupportDC42(); } return kMyErr_noErr; } LOCALPROC WrtOptSonySupportDC42(void) { WrtOptBooleanOption("-sony-dc42", SonySupportDC42, dfo_SonySupportDC42()); } /* option: Save Dialog Enable */ LOCALVAR blnr gbo_SaveDialogEnable; LOCALVAR ui3r olv_SaveDialogEnable; LOCALPROC ResetSaveDialogEnable(void) { gbo_SaveDialogEnable = nanblnr; olv_SaveDialogEnable = 0; } LOCALFUNC tMyErr TryAsSaveDialogEnable(void) { return BooleanTryAsOptionNot("-svd", &gbo_SaveDialogEnable, &olv_SaveDialogEnable); } #define dfo_SaveDialogEnable() trueblnr LOCALFUNC tMyErr ChooseSaveDialogEnable(void) { if (nanblnr == gbo_SaveDialogEnable) { gbo_SaveDialogEnable = dfo_SaveDialogEnable(); } return kMyErr_noErr; } LOCALPROC WrtOptSaveDialogEnable(void) { WrtOptBooleanOption("-svd", gbo_SaveDialogEnable, dfo_SaveDialogEnable()); } /* option: Insert Ith Disk Image */ LOCALVAR blnr WantInsertIthDisk; LOCALVAR ui3r olv_InsertIthDisk; LOCALPROC ResetInsertIthDisk(void) { WantInsertIthDisk = nanblnr; olv_InsertIthDisk = 0; } LOCALFUNC tMyErr TryAsInsertIthDisk(void) { return BooleanTryAsOptionNot("-iid", &WantInsertIthDisk, &olv_InsertIthDisk); } #define dfo_InsertIthDisk() falseblnr LOCALFUNC tMyErr ChooseInsertIthDisk(void) { if (nanblnr == WantInsertIthDisk) { WantInsertIthDisk = dfo_InsertIthDisk(); } return kMyErr_noErr; } LOCALPROC WrtOptInsertIthDisk(void) { WrtOptBooleanOption("-iid", WantInsertIthDisk, dfo_InsertIthDisk()); } /* option: Command Option Swap */ LOCALVAR blnr WantCmndOptSwap; LOCALVAR ui3r olv_CmndOptSwap; LOCALPROC ResetCmndOptSwap(void) { WantCmndOptSwap = falseblnr; olv_CmndOptSwap = 0; } LOCALFUNC tMyErr TryAsCmndOptSwapNot(void) { return FlagTryAsOptionNot("-ccs", &WantCmndOptSwap, &olv_CmndOptSwap); } LOCALFUNC tMyErr ChooseCmndOptSwap(void) { return kMyErr_noErr; } LOCALPROC WrtOptCmndOptSwap(void) { WrtOptFlagOption("-ccs", WantCmndOptSwap); } /* option: key mapping */ enum { gbk_keynam_Control, gbk_keynam_Command, gbk_keynam_Option, gbk_keynam_Shift, gbk_keynam_CapsLock, gbk_keynam_Escape, gbk_keynam_BackSlash, gbk_keynam_Slash, gbk_keynam_Grave, gbk_keynam_Enter, gbk_keynam_PageUp, gbk_keynam_PageDown, gbk_keynam_Home, gbk_keynam_End, gbk_keynam_Help, gbk_keynam_ForwardDel, gbk_keynam_F1, gbk_keynam_F2, gbk_keynam_F3, gbk_keynam_F4, gbk_keynam_F5, kNumKeyNames }; enum { gbk_keynam_RControl = kNumKeyNames, gbk_keynam_RCommand, gbk_keynam_ROption, gbk_keynam_RShift, kNumSrcKeyNames }; enum { gbk_keynam_CM = kNumKeyNames, kNumDstKeyNames }; LOCALVAR ui3b gbo_keymap[kNumSrcKeyNames]; LOCALVAR ui3r olv_keymap[kNumSrcKeyNames]; LOCALPROC ResetKeyMapOption(void) { uimr i; for (i = 0; i < kNumSrcKeyNames; ++i) { gbo_keymap[i] = 0xFF; olv_keymap[i] = 0; } } LOCALFUNC char * GetKeyMapName(int i) { char *s; switch (i) { case gbk_keynam_Control: s = "Control"; break; case gbk_keynam_Command: s = "Command"; break; case gbk_keynam_Option: s = "Option"; break; case gbk_keynam_Shift: s = "Shift"; break; case gbk_keynam_CapsLock: s = "CapsLock"; break; case gbk_keynam_Escape: s = "Escape"; break; case gbk_keynam_BackSlash: s = "BackSlash"; break; case gbk_keynam_Slash: s = "Slash"; break; case gbk_keynam_Grave: s = "Grave"; break; case gbk_keynam_Enter: s = "Enter"; break; case gbk_keynam_PageUp: s = "PageUp"; break; case gbk_keynam_PageDown: s = "PageDown"; break; case gbk_keynam_Home: s = "Home"; break; case gbk_keynam_End: s = "End"; break; case gbk_keynam_Help: s = "Help"; break; case gbk_keynam_ForwardDel: s = "ForwardDel"; break; case gbk_keynam_F1: s = "F1"; break; case gbk_keynam_F2: s = "F2"; break; case gbk_keynam_F3: s = "F3"; break; case gbk_keynam_F4: s = "F4"; break; case gbk_keynam_F5: s = "F5"; break; default: s = "(unknown key)"; break; } return s; } LOCALFUNC char * GetSrcKeyMapName(int i) { char *s; switch (i) { case gbk_keynam_RControl: s = "RControl"; break; case gbk_keynam_RCommand: s = "RCommand"; break; case gbk_keynam_ROption: s = "ROption"; break; case gbk_keynam_RShift: s = "RShift"; break; default: s = GetKeyMapName(i); break; } return s; } LOCALFUNC char * GetDstKeyMapName(int i) { char *s; switch (i) { case gbk_keynam_CM: s = "CM"; break; default: s = GetKeyMapName(i); break; } return s; } LOCALFUNC tMyErr TryAsKeyMapOptionNot(void) { tMyErr err; MyPStr t; int k; int j; if (! CurArgIsCStr_v2("-km")) { err = kMyErrNoMatch; } else if (kMyErr_noErr != (err = AdvanceTheArg())) { /* fail */ } else if (The_arg_end) { PStrFromCStr(t, "Expecting a src argument for -km when reached end"); err = ReportParseFailPStr(t); } else if (! GetCurArgNameIndex(kNumSrcKeyNames, GetSrcKeyMapName, &k)) { PStrFromCStr(t, "Unknown source value for -km"); err = ReportParseFailPStr(t); } else if (olv_keymap[k] == olv_cur) { PStrFromCStr(t, "same -km src value has appeared more than once"); err = ReportParseFailPStr(t); } else if (kMyErr_noErr != (err = AdvanceTheArg())) { /* fail */ } else if (The_arg_end) { PStrFromCStr(t, "Expecting a dst argument for -km when reached end"); err = ReportParseFailPStr(t); } else if (! GetCurArgNameIndex(kNumDstKeyNames, GetDstKeyMapName, &j)) { if (CurArgIsCStr_v2("*")) { olv_keymap[k] = olv_cur; gbo_keymap[k] = 0xFF; err = AdvanceTheArg(); } else { PStrFromCStr(t, "Unknown dst value for -km"); err = ReportParseFailPStr(t); } } else { olv_keymap[k] = olv_cur; gbo_keymap[k] = j; err = AdvanceTheArg(); } return err; } LOCALPROC dfo_keyset(ui3b *a, uimr i, ui3r v) { a[i] = v; if (0xFF == gbo_keymap[i]) { gbo_keymap[i] = v; } } LOCALPROC dfo_keymap(ui3b *a) { uimr i; dfo_keyset(a, gbk_keynam_Control, WantCmndOptSwap ? gbk_keynam_Command : gbk_keynam_CM); dfo_keyset(a, gbk_keynam_Command, WantCmndOptSwap ? gbk_keynam_CM : gbk_keynam_Command); for (i = gbk_keynam_Option; i <= gbk_keynam_ForwardDel; ++i) { dfo_keyset(a, i, i); } dfo_keyset(a, gbk_keynam_F1, gbk_keynam_Option); dfo_keyset(a, gbk_keynam_F2, gbk_keynam_Command); for (i = gbk_keynam_F3; i <= gbk_keynam_F5; ++i) { dfo_keyset(a, i, i); } dfo_keyset(a, gbk_keynam_RControl, gbo_keymap[gbk_keynam_Control]); dfo_keyset(a, gbk_keynam_RCommand, gbo_keymap[gbk_keynam_Command]); dfo_keyset(a, gbk_keynam_ROption, gbo_keymap[gbk_keynam_Option]); dfo_keyset(a, gbk_keynam_RShift, gbo_keymap[gbk_keynam_Shift]); } LOCALFUNC ui3r KeyMapInverse(uimr v) { uimr i; for (i = 0; i < kNumSrcKeyNames; ++i) { if (v == gbo_keymap[i]) { return i; } } return 0xFF; } LOCALVAR ui3r ControlModeKey; LOCALFUNC tMyErr ChooseKeyMap(void) { tMyErr err; ui3b a[kNumSrcKeyNames]; dfo_keymap(a); ControlModeKey = KeyMapInverse(gbk_keynam_CM); if (0xFF == ControlModeKey) { err = ReportParseFailure( "-km : no key maps to CM"); } else { err = kMyErr_noErr; } return err; } LOCALPROC WrtOptKeyMap(void) { ui3b a[kNumSrcKeyNames]; uimr i; dfo_keymap(a); for (i = 0; i < kNumSrcKeyNames; ++i) { if (gbo_keymap[i] != a[i]) { WriteCStrToDestFile(" -km "); WriteCStrToDestFile(GetSrcKeyMapName(i)); WriteCStrToDestFile(" "); WriteCStrToDestFile(GetDstKeyMapName(gbo_keymap[i])); } } } /* option: emulated key toggle mapping */ LOCALVAR int gbo_EKTMap; LOCALVAR ui3r olv_EKTMap; LOCALPROC ResetEKTMapOption(void) { gbo_EKTMap = kListOptionAuto; olv_EKTMap = 0; } LOCALFUNC tMyErr TryAsEKTMapOptionNot(void) { return FindNamedOption("-ekt", kNumKeyNames, GetKeyMapName, &gbo_EKTMap, &olv_EKTMap); } LOCALFUNC int dfo_EKTMap(void) { blnr a[kNumKeyNames]; uimr i; uimr j; for (i = 0; i < kNumKeyNames; ++i) { a[i] = falseblnr; } for (i = 0; i < kNumSrcKeyNames; ++i) { j = gbo_keymap[i]; if (j < kNumKeyNames) { a[j] = trueblnr; } } for (i = 0; i < kNumKeyNames; ++i) { if (! a[i]) { return i; } } return gbk_keynam_Control; } LOCALFUNC tMyErr ChooseEKTMap(void) { if (kListOptionAuto == gbo_EKTMap) { gbo_EKTMap = dfo_EKTMap(); } return kMyErr_noErr; } LOCALPROC WrtOptEKTMap(void) { WrtOptNamedOption("-ekt", GetKeyMapName, gbo_EKTMap, dfo_EKTMap()); } /* option: Alternate Keyboard Mode */ LOCALVAR blnr WantAltKeysMode; LOCALVAR ui3r olv_WantAltKeysMode; LOCALPROC ResetAltKeysMode(void) { WantAltKeysMode = falseblnr; olv_WantAltKeysMode = 0; } LOCALFUNC tMyErr TryAsAltKeysModeNot(void) { return FlagTryAsOptionNot("-akm", &WantAltKeysMode, &olv_WantAltKeysMode); } LOCALFUNC tMyErr ChooseAltKeysMode(void) { return kMyErr_noErr; } LOCALPROC WrtOptAltKeysMode(void) { WrtOptFlagOption("-akm", WantAltKeysMode); } /* option: ItnlKyBdFix */ LOCALVAR blnr ItnlKyBdFix; LOCALVAR ui3r olv_ItnlKyBdFix; LOCALPROC ResetItnlKyBdFixOption(void) { ItnlKyBdFix = nanblnr; } LOCALFUNC tMyErr TryAsItnlKyBdFixNot(void) { return BooleanTryAsOptionNot("-ikb", &ItnlKyBdFix, &olv_ItnlKyBdFix); } LOCALFUNC blnr dfo_ItnlKyBdFix(void) { blnr v; v = (gbk_apifam_win == gbo_apifam); return v; } LOCALFUNC tMyErr ChooseItnlKyBdFix(void) { tMyErr err = kMyErr_noErr; if (nanblnr == ItnlKyBdFix) { ItnlKyBdFix = dfo_ItnlKyBdFix(); } else { if (ItnlKyBdFix) { if (gbk_apifam_win != gbo_apifam) { err = ReportParseFailure("-ikb is only for Windows"); } } } return err; } LOCALPROC WrtOptItnlKyBdFix(void) { WrtOptBooleanOption("-ikb", ItnlKyBdFix, dfo_ItnlKyBdFix()); } /* option: LocalTalk emulation */ LOCALVAR blnr WantLocalTalk; LOCALVAR ui3r olv_LocalTalk; LOCALPROC ResetLocalTalk(void) { WantLocalTalk = falseblnr; olv_LocalTalk = 0; } LOCALFUNC tMyErr TryAsLocalTalkNot(void) { return FlagTryAsOptionNot("-lt", &WantLocalTalk, &olv_LocalTalk); } LOCALFUNC tMyErr ChooseLocalTalk(void) { tMyErr err; err = kMyErr_noErr; if (WantLocalTalk) { if ((gbk_apifam_osx != gbo_apifam) && (gbk_apifam_cco != gbo_apifam)) { err = ReportParseFailure( "-lt is so far only implemented for OS X"); } } return err; } LOCALPROC WrtOptLocalTalk(void) { WrtOptFlagOption("-lt", WantLocalTalk); } /* option: initial speed */ enum { gbk_speed_AllOut, gbk_speed_1X, gbk_speed_2X, gbk_speed_4X, gbk_speed_8X, gbk_speed_16X, gbk_speed_32X, kNumSpeeds }; LOCALVAR int CurInitSpeed; LOCALVAR ui3r olv_InitSpeed; LOCALPROC ResetInitSpeedOption(void) { CurInitSpeed = kListOptionAuto; olv_InitSpeed = 0; } LOCALFUNC char * GetInitSpeedName(int i) { char *s; switch (i) { case gbk_speed_AllOut: s = "a"; break; case gbk_speed_1X: s = "z"; break; case gbk_speed_2X: s = "1"; break; case gbk_speed_4X: s = "2"; break; case gbk_speed_8X: s = "3"; break; case gbk_speed_16X: s = "4"; break; case gbk_speed_32X: s = "5"; break; default: s = "(unknown Speed)"; break; } return s; } LOCALFUNC tMyErr TryAsInitSpeedOptionNot(void) { return FindNamedOption("-speed", kNumSpeeds, GetInitSpeedName, &CurInitSpeed, &olv_InitSpeed); } LOCALFUNC int dfo_InitSpeed(void) { int v; if (cur_mIIorIIX) { v = gbk_speed_4X; } else { v = gbk_speed_8X; } return v; } LOCALFUNC tMyErr ChooseInitSpeed(void) { if (kListOptionAuto == CurInitSpeed) { CurInitSpeed = dfo_InitSpeed(); } return kMyErr_noErr; } LOCALPROC WrtOptInitSpeedOption(void) { WrtOptNamedOption("-speed", GetInitSpeedName, CurInitSpeed, dfo_InitSpeed()); } /* option: Initial Run In Background */ LOCALVAR blnr WantInitBackground; LOCALVAR ui3r olv_InitBackground; LOCALPROC ResetInitBackground(void) { WantInitBackground = nanblnr; olv_InitBackground = 0; } LOCALFUNC tMyErr TryAsInitBackgroundNot(void) { return BooleanTryAsOptionNot("-bg", &WantInitBackground, &olv_InitBackground); } LOCALFUNC blnr dfo_InitBackground(void) { blnr v; if (WantLocalTalk) { v = trueblnr; } else { v = falseblnr; } return v; } LOCALFUNC tMyErr ChooseInitBackground(void) { if (nanblnr == WantInitBackground) { WantInitBackground = dfo_InitBackground(); } return kMyErr_noErr; } LOCALPROC WrtOptInitBackground(void) { WrtOptBooleanOption("-bg", WantInitBackground, dfo_InitBackground()); } /* option: Initial AutoSlow */ LOCALVAR blnr WantInitAutoSlow; LOCALVAR ui3r olv_InitAutoSlow; LOCALPROC ResetInitAutoSlow(void) { WantInitAutoSlow = nanblnr; olv_InitAutoSlow = 0; } LOCALFUNC tMyErr TryAsInitAutoSlowNot(void) { return BooleanTryAsOptionNot("-as", &WantInitAutoSlow, &olv_InitAutoSlow); } LOCALFUNC blnr dfo_InitAutoSlow(void) { blnr v; v = ! cur_mIIorIIX; return v; } LOCALFUNC tMyErr ChooseInitAutoSlow(void) { if (nanblnr == WantInitAutoSlow) { WantInitAutoSlow = dfo_InitAutoSlow(); } return kMyErr_noErr; } LOCALPROC WrtOptInitAutoSlow(void) { WrtOptBooleanOption("-as", WantInitAutoSlow, dfo_InitAutoSlow()); } /* option: Timing Accuracy */ LOCALVAR uimr timingacc; LOCALVAR ui3r olv_timingacc; LOCALPROC ResetTimingAccuracyOption(void) { olv_timingacc = 0; } LOCALFUNC tMyErr TryAsTimingAccuracyOptionNot(void) { return NumberTryAsOptionNot("-ta", (long *)&timingacc, &olv_timingacc); } #define dfo_timingacc() 1 LOCALFUNC tMyErr ChooseTimingAccuracy(void) { if (0 == olv_timingacc) { timingacc = dfo_timingacc(); } return kMyErr_noErr; } LOCALPROC WrtOptTimingAccuracy(void) { WrtOptNumberOption("-ta", timingacc, dfo_timingacc()); } /* option: Emulated CPU version */ LOCALVAR uimr em_cpu_vers; LOCALVAR ui3r olv_em_cpu_vers; LOCALPROC ResetEmCpuVersOption(void) { olv_em_cpu_vers = 0; } LOCALFUNC tMyErr TryAsEmCpuVersOptionNot(void) { return NumberTryAsOptionNot("-em-cpu", (long *)&em_cpu_vers, &olv_em_cpu_vers); } LOCALFUNC uimr dfo_em_cpu_vers(void) { uimr v; if (cur_mIIorIIX) { v = 2; } else { v = 0; } return v; } LOCALFUNC tMyErr ChooseEmCpuVers(void) { if (0 == olv_em_cpu_vers) { em_cpu_vers = dfo_em_cpu_vers(); } return kMyErr_noErr; } LOCALPROC WrtOptEmCpuVers(void) { WrtOptNumberOption("-em-cpu", em_cpu_vers, dfo_em_cpu_vers()); } /* option: memory size */ enum { gbk_msz_128K, gbk_msz_512K, gbk_msz_1M, gbk_msz_2M, gbk_msz_2_5M, gbk_msz_4M, gbk_msz_5M, gbk_msz_8M, kNumMemSizs }; LOCALVAR int cur_msz; LOCALVAR ui3r olv_msz; LOCALPROC ResetMemSizOption(void) { cur_msz = kListOptionAuto; olv_msz = 0; } LOCALFUNC char * GetMemSizName(int i) { char *s; switch (i) { case gbk_msz_128K: s = "128K"; break; case gbk_msz_512K: s = "512K"; break; case gbk_msz_1M: s = "1M"; break; case gbk_msz_2M: s = "2M"; break; case gbk_msz_2_5M: s = "2.5M"; break; case gbk_msz_4M: s = "4M"; break; case gbk_msz_5M: s = "5M"; break; case gbk_msz_8M: s = "8M"; break; default: s = "(unknown Memory Size)"; break; } return s; } LOCALFUNC tMyErr TryAsMemSizOptionNot(void) { return FindNamedOption("-mem", kNumMemSizs, GetMemSizName, &cur_msz, &olv_msz); } LOCALFUNC int dfo_msz(void) { int v; switch (cur_mdl) { case gbk_mdl_Twig43: case gbk_mdl_Twiggy: case gbk_mdl_128K: v = gbk_msz_128K; break; case gbk_mdl_512Ke: v = gbk_msz_512K; break; case gbk_mdl_II: case gbk_mdl_IIx: v = gbk_msz_8M; break; case gbk_mdl_Plus: case gbk_mdl_SE: case gbk_mdl_SEFDHD: case gbk_mdl_Classic: case gbk_mdl_PB100: default: v = gbk_msz_4M; break; } if (gbk_targfam_lnds == gbo_targfam) { if (v > gbk_msz_2M) { v = gbk_msz_2M; } } return v; } LOCALFUNC tMyErr ChooseMemSiz(void) { if (kListOptionAuto == cur_msz) { cur_msz = dfo_msz(); } else { /* should error check here */ /* no, checked in ChooseMemBankSizes */ } return kMyErr_noErr; } LOCALPROC WrtOptMemSizOption(void) { WrtOptNamedOption("-mem", GetMemSizName, cur_msz, dfo_msz()); } /* memory bank sizes */ LOCALVAR uimr RAMa_Size; LOCALVAR uimr RAMb_Size; #define ln2_msz_64K 16 #define ln2_msz_128K 17 #define ln2_msz_256K 18 #define ln2_msz_512K 19 #define ln2_msz_1M 20 #define ln2_msz_2M 21 #define ln2_msz_4M 22 #define ln2_msz_8M 23 LOCALFUNC tMyErr ChooseMemBankSizes(void) { tMyErr err; RAMa_Size = 0; RAMb_Size = 0; switch (cur_mdl) { case gbk_mdl_Twig43: case gbk_mdl_Twiggy: case gbk_mdl_128K: case gbk_mdl_512Ke: if (cur_msz == gbk_msz_128K) { RAMa_Size = ln2_msz_128K; } else if (cur_msz == gbk_msz_512K) { RAMa_Size = ln2_msz_512K; } else { /* unsupported */ } break; case gbk_mdl_Plus: case gbk_mdl_SE: case gbk_mdl_SEFDHD: case gbk_mdl_Classic: if (cur_msz == gbk_msz_128K) { if (gbk_mdl_Plus == cur_mdl) { RAMa_Size = ln2_msz_128K; } } else if (cur_msz == gbk_msz_512K) { RAMa_Size = ln2_msz_512K; } else if (cur_msz == gbk_msz_1M) { RAMa_Size = ln2_msz_512K; RAMb_Size = ln2_msz_512K; } else if (cur_msz == gbk_msz_2M) { RAMa_Size = ln2_msz_2M; } else if (cur_msz == gbk_msz_2_5M) { RAMa_Size = ln2_msz_2M; RAMb_Size = ln2_msz_512K; } else if (cur_msz == gbk_msz_4M) { RAMa_Size = ln2_msz_2M; RAMb_Size = ln2_msz_2M; } else { /* unsupported */ } break; case gbk_mdl_II: case gbk_mdl_IIx: if (cur_msz == gbk_msz_1M) { RAMa_Size = ln2_msz_1M; } else if (cur_msz == gbk_msz_2M) { RAMa_Size = ln2_msz_1M; RAMb_Size = ln2_msz_1M; } else if (cur_msz == gbk_msz_4M) { RAMa_Size = ln2_msz_4M; } else if (cur_msz == gbk_msz_5M) { RAMa_Size = ln2_msz_4M; RAMb_Size = ln2_msz_1M; } else if (cur_msz == gbk_msz_8M) { RAMa_Size = ln2_msz_4M; RAMb_Size = ln2_msz_4M; } else { /* unsupported */ } break; case gbk_mdl_PB100: if (cur_msz == gbk_msz_4M) { RAMa_Size = ln2_msz_4M; } else { /* unsupported */ } default: /* unsupported */ break; } if (0 == RAMa_Size) { err = ReportParseFailure( "memory size (-mem) unsupported for this model (-m)"); } else { err = kMyErr_noErr; } return err; } /* option: Parameter RAM CaretBlinkTime */ /* usually in 3 (Fast), 8 (Medium), 15 (Slow) */ LOCALVAR uimr cur_CaretBlinkTime; LOCALVAR ui3r olv_CaretBlinkTime; LOCALPROC ResetCaretBlinkTimeOption(void) { olv_CaretBlinkTime = 0; } LOCALFUNC tMyErr TryAsCaretBlinkTimeOptionNot(void) { return NumberTryAsOptionNot("-cbt", (long *)&cur_CaretBlinkTime, &olv_CaretBlinkTime); } LOCALFUNC uimr dfo_CaretBlinkTime(void) { uimr v; if (cur_mIIorIIX) { v = 8; } else { v = 3; } return v; } LOCALFUNC tMyErr ChooseCaretBlinkTime(void) { tMyErr err; err = kMyErr_noErr; if (0 == olv_CaretBlinkTime) { cur_CaretBlinkTime = dfo_CaretBlinkTime(); } else { if ((cur_CaretBlinkTime <= 0) || (cur_CaretBlinkTime > 15)) { err = ReportParseFailure( "-cbt must be a number between 1 and 15"); } } return err; } LOCALPROC WrtOptCaretBlinkTime(void) { WrtOptNumberOption("-cbt", cur_CaretBlinkTime, dfo_CaretBlinkTime()); } /* option: Parameter RAM DoubleClickTime */ /* usually in 5 (Fast), 8 (Medium), 12 (Slow) */ LOCALVAR uimr cur_DoubleClickTime; LOCALVAR ui3r olv_DoubleClickTime; LOCALPROC ResetDoubleClickTimeOption(void) { olv_DoubleClickTime = 0; } LOCALFUNC tMyErr TryAsDoubleClickTimeOptionNot(void) { return NumberTryAsOptionNot("-dct", (long *)&cur_DoubleClickTime, &olv_DoubleClickTime); } LOCALFUNC uimr dfo_DoubleClickTime(void) { uimr v; if (cur_mIIorIIX) { v = 8; } else { v = 5; } return v; } LOCALFUNC tMyErr ChooseDoubleClickTime(void) { tMyErr err; err = kMyErr_noErr; if (0 == olv_DoubleClickTime) { cur_DoubleClickTime = dfo_DoubleClickTime(); } else { if ((cur_DoubleClickTime <= 0) || (cur_DoubleClickTime > 15)) { err = ReportParseFailure( "-dct must be a number between 1 and 15"); } } return err; } LOCALPROC WrtOptDoubleClickTime(void) { WrtOptNumberOption("-dct", cur_DoubleClickTime, dfo_DoubleClickTime()); } /* option: Parameter RAM MenuBlink */ /* in 0..3 */ LOCALVAR uimr cur_MenuBlink; LOCALVAR ui3r olv_MenuBlink; LOCALPROC ResetMenuBlinkOption(void) { olv_MenuBlink = 0; } LOCALFUNC tMyErr TryAsMenuBlinkOptionNot(void) { return NumberTryAsOptionNot("-mnb", (long *)&cur_MenuBlink, &olv_MenuBlink); } #define dfo_MenuBlink() 3 LOCALFUNC tMyErr ChooseMenuBlink(void) { tMyErr err; err = kMyErr_noErr; if (0 == olv_MenuBlink) { cur_MenuBlink = dfo_MenuBlink(); } else { if (cur_MenuBlink > 3) { err = ReportParseFailure( "-mnb must be a number between 0 and 3"); } } return err; } LOCALPROC WrtOptMenuBlink(void) { WrtOptNumberOption("-mnb", cur_MenuBlink, dfo_MenuBlink()); } /* option: Parameter RAM AutoKeyThresh */ /* usually in 0 (Off), A (Long), 6, 4, 3 (Short) */ LOCALVAR uimr cur_AutoKeyThresh; LOCALVAR ui3r olv_AutoKeyThresh; LOCALPROC ResetAutoKeyThreshOption(void) { olv_AutoKeyThresh = 0; } LOCALFUNC tMyErr TryAsAutoKeyThreshOptionNot(void) { return NumberTryAsOptionNot("-kyt", (long *)&cur_AutoKeyThresh, &olv_AutoKeyThresh); } #define dfo_AutoKeyThresh() 6 LOCALFUNC tMyErr ChooseAutoKeyThresh(void) { tMyErr err; err = kMyErr_noErr; if (0 == olv_AutoKeyThresh) { cur_AutoKeyThresh = dfo_AutoKeyThresh(); } else { if (cur_AutoKeyThresh > 15) { err = ReportParseFailure( "-kyt must be a number between 0 and 15"); } } return err; } LOCALPROC WrtOptAutoKeyThresh(void) { WrtOptNumberOption("-kyt", cur_AutoKeyThresh, dfo_AutoKeyThresh()); } /* option: Parameter RAM AutoKeyRate */ /* usually in 0 (Slow), 6, 4, 3, 1 (Fast) */ LOCALVAR uimr cur_AutoKeyRate; LOCALVAR ui3r olv_AutoKeyRate; LOCALPROC ResetAutoKeyRateOption(void) { olv_AutoKeyRate = 0; } LOCALFUNC tMyErr TryAsAutoKeyRateOptionNot(void) { return NumberTryAsOptionNot("-kyr", (long *)&cur_AutoKeyRate, &olv_AutoKeyRate); } #define dfo_AutoKeyRate() 3 LOCALFUNC tMyErr ChooseAutoKeyRate(void) { tMyErr err; err = kMyErr_noErr; if (0 == olv_AutoKeyRate) { cur_AutoKeyRate = dfo_AutoKeyRate(); } else { if (cur_AutoKeyRate > 15) { err = ReportParseFailure( "-kyr must be a number between 0 and 15"); } } return err; } LOCALPROC WrtOptAutoKeyRate(void) { WrtOptNumberOption("-kyr", cur_AutoKeyRate, dfo_AutoKeyRate()); } LOCALFUNC tMyErr ChooseHilColPart(char *s, uimr *cur_HilColV, ui3r olv_HilColV, uimr dfo_HilColV) { tMyErr err; MyPStr t; err = kMyErr_noErr; if (0 == olv_HilColV) { *cur_HilColV = dfo_HilColV; } else { if (! cur_mIIorIIX) { if (0 != *cur_HilColV) { PStrFromCStr(t, s); PStrApndCStr(t, " not allowed for this emulated computer"); err = ReportParseFailPStr(t); } } else if (*cur_HilColV > 65535) { PStrFromCStr(t, s); PStrApndCStr(t, " must be a number between 0 and 65535"); err = ReportParseFailPStr(t); } } return err; } /* option: Parameter RAM HilColRed */ LOCALVAR uimr cur_HilColRed; LOCALVAR ui3r olv_HilColRed; LOCALPROC ResetHilColRedOption(void) { olv_HilColRed = 0; } LOCALFUNC tMyErr TryAsHilColRedOptionNot(void) { return NumberTryAsOptionNot("-hcr", (long *)&cur_HilColRed, &olv_HilColRed); } #define dfo_HilColRed() 0 LOCALFUNC tMyErr ChooseHilColRed(void) { return ChooseHilColPart("-hcr", &cur_HilColRed, olv_HilColRed, dfo_HilColRed()); } LOCALPROC WrtOptHilColRed(void) { WrtOptNumberOption("-hcr", cur_HilColRed, dfo_HilColRed()); } /* option: Parameter RAM HilColGreen */ LOCALVAR uimr cur_HilColGreen; LOCALVAR ui3r olv_HilColGreen; LOCALPROC ResetHilColGreenOption(void) { olv_HilColGreen = 0; } LOCALFUNC tMyErr TryAsHilColGreenOptionNot(void) { return NumberTryAsOptionNot("-hcg", (long *)&cur_HilColGreen, &olv_HilColGreen); } #define dfo_HilColGreen() 0 LOCALFUNC tMyErr ChooseHilColGreen(void) { return ChooseHilColPart("-hcg", &cur_HilColGreen, olv_HilColGreen, dfo_HilColGreen()); } LOCALPROC WrtOptHilColGreen(void) { WrtOptNumberOption("-hcg", cur_HilColGreen, dfo_HilColGreen()); } /* option: Parameter RAM HilColBlue */ LOCALVAR uimr cur_HilColBlue; LOCALVAR ui3r olv_HilColBlue; LOCALPROC ResetHilColBlueOption(void) { olv_HilColBlue = 0; } LOCALFUNC tMyErr TryAsHilColBlueOptionNot(void) { return NumberTryAsOptionNot("-hcb", (long *)&cur_HilColBlue, &olv_HilColBlue); } #define dfo_HilColBlue() 0 LOCALFUNC tMyErr ChooseHilColBlue(void) { return ChooseHilColPart("-hcb", &cur_HilColBlue, olv_HilColBlue, dfo_HilColBlue()); } LOCALPROC WrtOptHilColBlue(void) { WrtOptNumberOption("-hcb", cur_HilColBlue, dfo_HilColBlue()); } /* option: Automatic Location */ LOCALVAR blnr WantAutoLocation; LOCALVAR ui3r olv_AutoLocation; LOCALPROC ResetAutoLocation(void) { WantAutoLocation = nanblnr; olv_AutoLocation = 0; } LOCALFUNC tMyErr TryAsAutoLocationNot(void) { return BooleanTryAsOptionNot("-alc", &WantAutoLocation, &olv_AutoLocation); } #define dfo_AutoLocation() trueblnr LOCALFUNC tMyErr ChooseAutoLocation(void) { tMyErr err; err = kMyErr_noErr; if (nanblnr == WantAutoLocation) { WantAutoLocation = dfo_AutoLocation(); } else { if (cur_mdl < gbk_mdl_Plus) { err = ReportParseFailure( "-alc not supported for this model (-m)"); } } return err; } LOCALPROC WrtOptAutoLocation(void) { WrtOptBooleanOption("-alc", WantAutoLocation, dfo_AutoLocation()); } /* option: Location Latitude */ LOCALVAR uimr cur_InitLatitude; LOCALVAR ui3r olv_InitLatitude; LOCALPROC ResetInitLatitudeOption(void) { olv_InitLatitude = 0; } LOCALFUNC tMyErr TryAsInitLatitudeOptionNot(void) { return NumberTryAsOptionNot("-lcy", (long *)&cur_InitLatitude, &olv_InitLatitude); } #define dfo_InitLatitude() 0 LOCALFUNC tMyErr ChooseInitLatitude(void) { tMyErr err; err = kMyErr_noErr; if (0 == olv_InitLatitude) { cur_InitLatitude = dfo_InitLatitude(); } else { if (cur_mdl < gbk_mdl_Plus) { err = ReportParseFailure( "-lcy not supported for this model (-m)"); } } return err; } LOCALPROC WrtOptInitLatitude(void) { if (! WantAutoLocation) { WrtOptSimrOption("-lcy", cur_InitLatitude, dfo_InitLatitude()); } } /* option: Location Longitude */ LOCALVAR simr cur_InitLongitude; LOCALVAR ui3r olv_InitLongitude; LOCALPROC ResetInitLongitudeOption(void) { olv_InitLongitude = 0; } LOCALFUNC tMyErr TryAsInitLongitudeOptionNot(void) { return NumberTryAsOptionNot("-lcx", &cur_InitLongitude, &olv_InitLongitude); } #define dfo_InitLongitude() 0 LOCALFUNC tMyErr ChooseInitLongitude(void) { tMyErr err; err = kMyErr_noErr; if (0 == olv_InitLongitude) { cur_InitLongitude = dfo_InitLongitude(); } else { if (cur_mdl < gbk_mdl_Plus) { err = ReportParseFailure( "-lcx not supported for this model (-m)"); } } return err; } LOCALPROC WrtOptInitLongitude(void) { if (! WantAutoLocation) { WrtOptSimrOption("-lcx", cur_InitLongitude, dfo_InitLongitude()); } } /* option: Automatic Time Zone */ LOCALVAR blnr WantAutoTimeZone; LOCALVAR ui3r olv_AutoTimeZone; LOCALPROC ResetAutoTimeZone(void) { WantAutoTimeZone = nanblnr; olv_AutoTimeZone = 0; } LOCALFUNC tMyErr TryAsAutoTimeZoneNot(void) { return BooleanTryAsOptionNot("-atz", &WantAutoTimeZone, &olv_AutoTimeZone); } #define dfo_AutoTimeZone() trueblnr LOCALFUNC tMyErr ChooseAutoTimeZone(void) { tMyErr err; err = kMyErr_noErr; if (nanblnr == WantAutoTimeZone) { WantAutoTimeZone = dfo_AutoTimeZone(); } else { if (cur_mdl < gbk_mdl_Plus) { err = ReportParseFailure( "-atz not supported for this model (-m)"); } } return err; } LOCALPROC WrtOptAutoTimeZone(void) { WrtOptBooleanOption("-atz", WantAutoTimeZone, dfo_AutoTimeZone()); } /* option: Daylight Savings Time */ LOCALVAR blnr WantTzDST; LOCALVAR ui3r olv_TzDST; LOCALPROC ResetTzDST(void) { WantTzDST = nanblnr; olv_TzDST = 0; } LOCALFUNC tMyErr TryAsTzDSTNot(void) { return BooleanTryAsOptionNot("-lcd", &WantTzDST, &olv_TzDST); } #define dfo_TzDST() falseblnr LOCALFUNC tMyErr ChooseTzDST(void) { tMyErr err; err = kMyErr_noErr; if (nanblnr == WantTzDST) { WantTzDST = dfo_TzDST(); } else { if (cur_mdl < gbk_mdl_Plus) { err = ReportParseFailure( "-lcd not supported for this model (-m)"); } } return err; } LOCALPROC WrtOptTzDST(void) { if (! WantAutoTimeZone) { WrtOptBooleanOption("-lcd", WantTzDST, dfo_TzDST()); } } /* option: Time Zone Delta Hours */ LOCALVAR simr cur_TzDeltH; LOCALVAR ui3r olv_TzDeltH; LOCALPROC ResetTzDeltHOption(void) { olv_TzDeltH = 0; } LOCALFUNC tMyErr TryAsTzDeltHOptionNot(void) { return NumberTryAsOptionNot("-lcz", &cur_TzDeltH, &olv_TzDeltH); } /* option: Time Zone Delta Seconds */ LOCALVAR simr cur_TzDeltS; LOCALVAR ui3r olv_TzDeltS; LOCALPROC ResetTzDeltSOption(void) { olv_TzDeltS = 0; } LOCALFUNC tMyErr TryAsTzDeltSOptionNot(void) { return NumberTryAsOptionNot("-lczs", &cur_TzDeltS, &olv_TzDeltS); } #define dfo_TzDeltS() 0 LOCALFUNC tMyErr ChooseTzDeltS(void) { tMyErr err; err = kMyErr_noErr; if (cur_mdl < gbk_mdl_Plus) { if ((0 != olv_TzDeltS) || (0 != olv_TzDeltH)) { err = ReportParseFailure( "-lczs and -lcz are not supported for this model (-m)"); } } else if (0 == olv_TzDeltS) { if (0 == olv_TzDeltH) { cur_TzDeltS = dfo_TzDeltS(); } else { cur_TzDeltS = cur_TzDeltH * 3600; } } else { if (0 != olv_TzDeltH) { err = ReportParseFailure( "-lczs and -lcz can not both be used"); } } return err; } LOCALPROC WrtOptTzDeltS(void) { if (! WantAutoTimeZone) { simr t = cur_TzDeltS / 3600; if (t * 3600 == cur_TzDeltS) { WrtOptSimrOption("-lcz", t, 0); } else { WrtOptSimrOption("-lczs", cur_TzDeltS, dfo_TzDeltS()); } } } /* option: Speaker Volume */ /* usually in 3 (Fast), 8 (Medium), 15 (Slow) */ LOCALVAR uimr cur_SpeakerVol; LOCALVAR ui3r olv_SpeakerVol; LOCALPROC ResetSpeakerVolOption(void) { olv_SpeakerVol = 0; } LOCALFUNC tMyErr TryAsSpeakerVolOptionNot(void) { return NumberTryAsOptionNot("-svl", (long *)&cur_SpeakerVol, &olv_SpeakerVol); } LOCALFUNC uimr dfo_SpeakerVol(void) { uimr v; if (MySoundEnabled) { v = 7; } else { v = 0; } return v; } LOCALFUNC tMyErr ChooseSpeakerVol(void) { tMyErr err; err = kMyErr_noErr; if (0 == olv_SpeakerVol) { cur_SpeakerVol = dfo_SpeakerVol(); } else { if (cur_SpeakerVol >= 8) { err = ReportParseFailure( "-svl must be a number between 0 and 7"); } } return err; } LOCALPROC WrtOptSpeakerVol(void) { WrtOptNumberOption("-svl", cur_SpeakerVol, dfo_SpeakerVol()); } /* option: Minimum Extension */ LOCALVAR blnr WantMinExtn; LOCALVAR ui3r olv_WantMinExtn; LOCALPROC ResetWantMinExtn(void) { WantMinExtn = falseblnr; olv_WantMinExtn = 0; } LOCALFUNC tMyErr TryAsWantMinExtnNot(void) { return FlagTryAsOptionNot("-min-extn", &WantMinExtn, &olv_WantMinExtn); } LOCALFUNC tMyErr ChooseWantMinExtn(void) { return kMyErr_noErr; } LOCALPROC WrtOptMinExtn(void) { WrtOptFlagOption("-min-extn", WantMinExtn); } /* option: MouseMotion */ LOCALVAR blnr MyMouseMotion; LOCALVAR ui3r olv_MouseMotion; LOCALPROC ResetMouseMotionOption(void) { MyMouseMotion = nanblnr; olv_MouseMotion = 0; } LOCALFUNC tMyErr TryAsMouseMotionOptionNot(void) { return BooleanTryAsOptionNot("-emm", &MyMouseMotion, &olv_MouseMotion); } LOCALFUNC blnr dfo_MouseMotion(void) { blnr v; v = (gbk_apifam_gtk != gbo_apifam); return v; } LOCALFUNC tMyErr ChooseMouseMotion(void) { if (nanblnr == MyMouseMotion) { MyMouseMotion = dfo_MouseMotion(); } return kMyErr_noErr; } LOCALPROC WrtOptMouseMotion(void) { WrtOptBooleanOption("-emm", MyMouseMotion, dfo_MouseMotion()); } /* option: GrabKeysFullScreen */ LOCALVAR blnr WantGrabKeysFS; LOCALVAR ui3r olv_GrabKeysFS; LOCALPROC ResetGrabKeysFS(void) { WantGrabKeysFS = nanblnr; olv_GrabKeysFS = 0; } LOCALFUNC tMyErr TryAsGrabKeysFSNot(void) { return BooleanTryAsOptionNot("-gkf", &WantGrabKeysFS, &olv_GrabKeysFS); } #define dfo_GrabKeysFS() trueblnr LOCALFUNC tMyErr ChooseGrabKeysFS(void) { if (nanblnr == WantGrabKeysFS) { WantGrabKeysFS = dfo_GrabKeysFS(); } return kMyErr_noErr; } LOCALPROC WrtOptGrabKeysFS(void) { WrtOptBooleanOption("-gkf", WantGrabKeysFS, dfo_GrabKeysFS()); } /* option: Enable Control Interrupt */ LOCALVAR blnr WantEnblCtrlInt; LOCALVAR ui3r olv_EnblCtrlInt; LOCALPROC ResetEnblCtrlInt(void) { WantEnblCtrlInt = nanblnr; olv_EnblCtrlInt = 0; } LOCALFUNC tMyErr TryAsEnblCtrlIntNot(void) { return BooleanTryAsOptionNot("-eci", &WantEnblCtrlInt, &olv_EnblCtrlInt); } #define dfo_EnblCtrlInt() trueblnr LOCALFUNC tMyErr ChooseEnblCtrlInt(void) { if (nanblnr == WantEnblCtrlInt) { WantEnblCtrlInt = dfo_EnblCtrlInt(); } return kMyErr_noErr; } LOCALPROC WrtOptEnblCtrlInt(void) { WrtOptBooleanOption("-eci", WantEnblCtrlInt, dfo_EnblCtrlInt()); } /* option: Enable Control Reset */ LOCALVAR blnr WantEnblCtrlRst; LOCALVAR ui3r olv_EnblCtrlRst; LOCALPROC ResetEnblCtrlRst(void) { WantEnblCtrlRst = nanblnr; olv_EnblCtrlRst = 0; } LOCALFUNC tMyErr TryAsEnblCtrlRstNot(void) { return BooleanTryAsOptionNot("-ecr", &WantEnblCtrlRst, &olv_EnblCtrlRst); } #define dfo_EnblCtrlRst() trueblnr LOCALFUNC tMyErr ChooseEnblCtrlRst(void) { if (nanblnr == WantEnblCtrlRst) { WantEnblCtrlRst = dfo_EnblCtrlRst(); } return kMyErr_noErr; } LOCALPROC WrtOptEnblCtrlRst(void) { WrtOptBooleanOption("-ecr", WantEnblCtrlRst, dfo_EnblCtrlRst()); } /* option: Enable Control K (emulated control toggle) */ LOCALVAR blnr WantEnblCtrlKtg; LOCALVAR ui3r olv_EnblCtrlKtg; LOCALPROC ResetEnblCtrlKtg(void) { WantEnblCtrlKtg = nanblnr; olv_EnblCtrlKtg = 0; } LOCALFUNC tMyErr TryAsEnblCtrlKtgNot(void) { return BooleanTryAsOptionNot("-eck", &WantEnblCtrlKtg, &olv_EnblCtrlKtg); } #define dfo_EnblCtrlKtg() trueblnr LOCALFUNC tMyErr ChooseEnblCtrlKtg(void) { if (nanblnr == WantEnblCtrlKtg) { WantEnblCtrlKtg = dfo_EnblCtrlKtg(); } return kMyErr_noErr; } LOCALPROC WrtOptEnblCtrlKtg(void) { WrtOptBooleanOption("-eck", WantEnblCtrlKtg, dfo_EnblCtrlKtg()); } /* option: Want Color Image */ LOCALVAR blnr WantColorImage; LOCALVAR ui3r olv_ColorImage; LOCALPROC ResetWantColorImage(void) { WantColorImage = nanblnr; olv_ColorImage = 0; } LOCALFUNC tMyErr TryAsWantColorImageNot(void) { return BooleanTryAsOptionNot("-ci", &WantColorImage, &olv_ColorImage); } LOCALFUNC blnr dfo_ColorImage(void) { blnr v; if (gbk_apifam_xwn == gbo_apifam) { v = trueblnr; } else { /* leave as default */ v = nanblnr; } return v; } LOCALFUNC tMyErr ChooseWantColorImage(void) { tMyErr err; err = kMyErr_noErr; if (nanblnr == WantColorImage) { WantColorImage = dfo_ColorImage(); } else { if (gbk_apifam_xwn != gbo_apifam) { err = ReportParseFailure( "-ci is only for -api xwn"); } else if ((! WantColorImage) && (cur_ScrnDpth != 0)) { err = ReportParseFailure( "-ci 0 requires -depth 0"); } else { /* ok */ } } return err; } LOCALPROC WrtOptColorImage(void) { WrtOptBooleanOption("-ci", WantColorImage, dfo_ColorImage()); } /* option: Alternate Happy Mac Icons */ enum { gbk_AHM_none, gbk_AHM_aside, gbk_AHM_cheese, gbk_AHM_evil, gbk_AHM_horror, gbk_AHM_lady_mac, gbk_AHM_moustache, gbk_AHM_nerdy, gbk_AHM_pirate, gbk_AHM_sleepy, gbk_AHM_sly, gbk_AHM_sunglasses, gbk_AHM_surprise, gbk_AHM_tongue, gbk_AHM_yuck, gbk_AHM_zombie, kNumAHMs }; LOCALVAR int cur_AltHappyMac; LOCALVAR ui3r olv_AltHappyMac; LOCALPROC ResetAltHappyMacOption(void) { cur_AltHappyMac = kListOptionAuto; olv_AltHappyMac = 0; } LOCALFUNC char * GetAltHappyMacName(int i) { char *s; switch (i) { case gbk_AHM_none: s = "none"; break; case gbk_AHM_aside: s = "aside"; break; case gbk_AHM_cheese: s = "cheese"; break; case gbk_AHM_evil: s = "evil"; break; case gbk_AHM_horror: s = "horror"; break; case gbk_AHM_lady_mac: s = "lady_mac"; break; case gbk_AHM_moustache: s = "moustache"; break; case gbk_AHM_nerdy: s = "nerdy"; break; case gbk_AHM_pirate: s = "pirate"; break; case gbk_AHM_sleepy: s = "sleepy"; break; case gbk_AHM_sly: s = "sly"; break; case gbk_AHM_sunglasses: s = "sunglasses"; break; case gbk_AHM_surprise: s = "surprise"; break; case gbk_AHM_tongue: s = "tongue"; break; case gbk_AHM_yuck: s = "yuck"; break; case gbk_AHM_zombie: s = "zombie"; break; default: s = "(unknown Alt Happy Mac Icon)"; break; } return s; } LOCALFUNC tMyErr TryAsAltHappyMacOptionNot(void) { return FindNamedOption("-ahm", kNumAHMs, GetAltHappyMacName, &cur_AltHappyMac, &olv_AltHappyMac); } #define dfo_AltHappyMac() gbk_AHM_none LOCALFUNC tMyErr ChooseAltHappyMac(void) { if (kListOptionAuto == cur_AltHappyMac) { cur_AltHappyMac = dfo_AltHappyMac(); } return kMyErr_noErr; } LOCALPROC WrtOptAltHappyMac(void) { WrtOptNamedOption("-ahm", GetAltHappyMacName, cur_AltHappyMac, dfo_AltHappyMac()); } /* option: ROM size */ LOCALVAR uimr cur_RomSize; LOCALVAR ui3r olv_RomSize; LOCALPROC ResetRomSizeOption(void) { olv_RomSize = 0; } LOCALFUNC tMyErr TryAsRomSizeOptionNot(void) { return NumberTryAsOptionNot("-rsz", (long *)&cur_RomSize, &olv_RomSize); } LOCALFUNC uimr dfo_RomSize(void) { uimr v; switch (cur_mdl) { case gbk_mdl_Twig43: case gbk_mdl_Twiggy: case gbk_mdl_128K: v = ln2_msz_64K; /* 64 KB */ break; case gbk_mdl_512Ke: case gbk_mdl_Plus: v = ln2_msz_128K; /* 128 KB */ break; case gbk_mdl_SE: case gbk_mdl_SEFDHD: case gbk_mdl_PB100: case gbk_mdl_II: case gbk_mdl_IIx: v = ln2_msz_256K; /* 256 KB */ break; case gbk_mdl_Classic: default: v = ln2_msz_512K; /* 512 KB */ break; } return v; } LOCALFUNC tMyErr ChooseRomSize(void) { tMyErr err; err = kMyErr_noErr; if (0 == olv_RomSize) { cur_RomSize = dfo_RomSize(); } else { if ((cur_RomSize < 16) || (cur_RomSize > 31)) { err = ReportParseFailure( "-rsz must be a number between 16 and 31"); } } return err; } LOCALPROC WrtOptRomSize(void) { WrtOptNumberOption("-rsz", cur_RomSize, dfo_RomSize()); } /* option: Want Check RomCheck Sum */ LOCALVAR blnr WantCheckRomCheckSum; LOCALVAR ui3r olv_CheckRomCheckSum; LOCALPROC ResetCheckRomCheckSum(void) { WantCheckRomCheckSum = nanblnr; olv_CheckRomCheckSum = 0; } LOCALFUNC tMyErr TryAsCheckRomCheckSumNot(void) { return BooleanTryAsOptionNot("-chr", &WantCheckRomCheckSum, &olv_CheckRomCheckSum); } #define dfo_CheckRomCheckSum() trueblnr LOCALFUNC tMyErr ChooseCheckRomCheckSum(void) { if (nanblnr == WantCheckRomCheckSum) { WantCheckRomCheckSum = dfo_CheckRomCheckSum(); } return kMyErr_noErr; } LOCALPROC WrtOptCheckRomCheckSum(void) { WrtOptBooleanOption("-chr", WantCheckRomCheckSum, dfo_CheckRomCheckSum()); } /* option: Want Disable Rom Check */ LOCALVAR blnr WantDisableRomCheck; LOCALVAR ui3r olv_DisableRomCheck; LOCALPROC ResetDisableRomCheck(void) { WantDisableRomCheck = nanblnr; olv_DisableRomCheck = 0; } LOCALFUNC tMyErr TryAsDisableRomCheckNot(void) { return BooleanTryAsOptionNot("-drc", &WantDisableRomCheck, &olv_DisableRomCheck); } #define dfo_DisableRomCheck() trueblnr LOCALFUNC tMyErr ChooseDisableRomCheck(void) { if (nanblnr == WantDisableRomCheck) { WantDisableRomCheck = dfo_DisableRomCheck(); } return kMyErr_noErr; } LOCALPROC WrtOptDisableRomCheck(void) { WrtOptBooleanOption("-drc", WantDisableRomCheck, dfo_DisableRomCheck()); } /* option: Want Disable Ram Test */ LOCALVAR blnr WantDisableRamTest; LOCALVAR ui3r olv_DisableRamTest; LOCALPROC ResetDisableRamTest(void) { WantDisableRamTest = nanblnr; olv_DisableRamTest = 0; } LOCALFUNC tMyErr TryAsDisableRamTestNot(void) { return BooleanTryAsOptionNot("-drt", &WantDisableRamTest, &olv_DisableRamTest); } #define dfo_DisableRamTest() trueblnr LOCALFUNC tMyErr ChooseDisableRamTest(void) { if (nanblnr == WantDisableRamTest) { WantDisableRamTest = dfo_DisableRamTest(); } return kMyErr_noErr; } LOCALPROC WrtOptDisableRamTest(void) { WrtOptBooleanOption("-drt", WantDisableRamTest, dfo_DisableRamTest()); } /* option: Want Disassembly */ LOCALVAR blnr WantDisasm; LOCALVAR ui3r olv_WantDisasm; LOCALPROC ResetWantDisasm(void) { WantDisasm = nanblnr; olv_WantDisasm = 0; } LOCALFUNC tMyErr TryAsWantDisasmNot(void) { return BooleanTryAsOptionNot("-dis", &WantDisasm, &olv_WantDisasm); } #define dfo_WantDisasm() falseblnr LOCALFUNC tMyErr ChooseWantDisasm(void) { if (nanblnr == WantDisasm) { WantDisasm = dfo_WantDisasm(); } return kMyErr_noErr; } LOCALPROC WrtOptWantDisasmNot(void) { WrtOptBooleanOption("-dis", WantDisasm, dfo_WantDisasm()); } /* option: dbglog_HAVE */ LOCALVAR blnr DbgLogHAVE; LOCALVAR ui3r olv_DbgLogHAVE; LOCALPROC ResetDbgLogHAVE(void) { DbgLogHAVE = nanblnr; olv_DbgLogHAVE = 0; } LOCALFUNC tMyErr TryAsDbgLogHAVENot(void) { return BooleanTryAsOptionNot("-log", &DbgLogHAVE, &olv_DbgLogHAVE); } #define dfo_DbgLogHAVE() WantDisasm LOCALFUNC tMyErr ChooseDbgLogHAVE(void) { if (nanblnr == DbgLogHAVE) { DbgLogHAVE = dfo_DbgLogHAVE(); } return kMyErr_noErr; } LOCALPROC WrtOptDbgLogHAVE(void) { WrtOptBooleanOption("-log", DbgLogHAVE, dfo_DbgLogHAVE()); } /* option: Abnormal Reports */ LOCALVAR blnr gbo_AbnormalReports; LOCALVAR ui3r olv_AbnormalReports; LOCALPROC ResetAbnormalReports(void) { gbo_AbnormalReports = nanblnr; olv_AbnormalReports = 0; } LOCALFUNC tMyErr TryAsAbnormalReportsNot(void) { return BooleanTryAsOptionNot("-abr", &gbo_AbnormalReports, &olv_AbnormalReports); } #define dfo_AbnormalReports() DbgLogHAVE LOCALFUNC tMyErr ChooseAbnormalReports(void) { if (nanblnr == gbo_AbnormalReports) { gbo_AbnormalReports = dfo_AbnormalReports(); } return kMyErr_noErr; } LOCALPROC WrtOptAbnormalReports(void) { WrtOptBooleanOption("-abr", gbo_AbnormalReports, dfo_AbnormalReports()); } /* option: Screen VSync */ LOCALVAR blnr WantScreenVSync; LOCALVAR ui3r olv_ScreenVSync; LOCALPROC ResetScreenVSync(void) { WantScreenVSync = nanblnr; olv_ScreenVSync = 0; } LOCALFUNC tMyErr TryAsScreenVSyncNot(void) { return BooleanTryAsOptionNot("-vsync", &WantScreenVSync, &olv_ScreenVSync); } #define dfo_ScreenVSync() falseblnr LOCALFUNC tMyErr ChooseScreenVSync(void) { tMyErr err; err = kMyErr_noErr; if (nanblnr == WantScreenVSync) { WantScreenVSync = dfo_ScreenVSync(); } else { if (WantScreenVSync && (gbk_apifam_osx != gbo_apifam)) { err = ReportParseFailure( "-vsync is so far only implemented for OS X"); } } return err; } LOCALPROC WrtOptScreenVSync(void) { WrtOptBooleanOption("-vsync", WantScreenVSync, dfo_ScreenVSync()); } /* option: Graphics Switching */ LOCALVAR blnr WantGraphicsSwitching; LOCALVAR ui3r olv_GraphicsSwitching; LOCALPROC ResetGraphicsSwitching(void) { WantGraphicsSwitching = nanblnr; olv_GraphicsSwitching = 0; } LOCALFUNC tMyErr TryAsGraphicsSwitchingNot(void) { return BooleanTryAsOptionNot("-gse", &WantGraphicsSwitching, &olv_GraphicsSwitching); } #define dfo_GraphicsSwitching() falseblnr LOCALFUNC tMyErr ChooseGraphicsSwitching(void) { tMyErr err; err = kMyErr_noErr; if (nanblnr == WantGraphicsSwitching) { WantGraphicsSwitching = dfo_GraphicsSwitching(); } else { if (WantGraphicsSwitching && (gbk_apifam_cco != gbo_apifam)) { err = ReportParseFailure( "-gse is so far only implemented for cocoa on OS X"); } } return err; } LOCALPROC WrtOptGraphicsSwitching(void) { WrtOptBooleanOption("-gse", WantGraphicsSwitching, dfo_GraphicsSwitching()); } /* option: Signing */ LOCALVAR blnr WantSigning; LOCALVAR ui3r olv_Signing; LOCALPROC ResetSigning(void) { WantSigning = nanblnr; olv_Signing = 0; } LOCALFUNC tMyErr TryAsSigningNot(void) { return BooleanTryAsOptionNot("-sgn", &WantSigning, &olv_Signing); } LOCALFUNC blnr dfo_Signing(void) { blnr v; v = (gbk_apifam_cco == gbo_apifam); return v; } LOCALFUNC tMyErr ChooseSigning(void) { tMyErr err; err = kMyErr_noErr; if (nanblnr == WantSigning) { WantSigning = dfo_Signing(); } else { if (WantSigning && (gbk_apifam_cco != gbo_apifam)) { err = ReportParseFailure( "-sgn is so far only implemented for cocoa on OS X"); } } return err; } LOCALPROC WrtOptSigning(void) { WrtOptBooleanOption("-sgn", WantSigning, dfo_Signing()); } /* option: Sandbox */ LOCALVAR blnr WantSandbox; LOCALVAR ui3r olv_Sandbox; LOCALPROC ResetSandbox(void) { WantSandbox = nanblnr; olv_Sandbox = 0; } LOCALFUNC tMyErr TryAsSandboxNot(void) { return BooleanTryAsOptionNot("-sbx", &WantSandbox, &olv_Sandbox); } #define dfo_Sandbox() falseblnr LOCALFUNC tMyErr ChooseSandbox(void) { tMyErr err; err = kMyErr_noErr; if (nanblnr == WantSandbox) { WantSandbox = dfo_Sandbox(); } else { if (WantSandbox) { if (gbk_apifam_cco != gbo_apifam) { err = ReportParseFailure("-sbx" " is so far only implemented for cocoa on OS X"); } else if (! WantSigning) { err = ReportParseFailure("-sbx" " requires -sgn 1"); } else { /* ok */ } } } return err; } LOCALPROC WrtOptSandbox(void) { WrtOptBooleanOption("-sbx", WantSandbox, dfo_Sandbox()); } /* ------ */ LOCALVAR blnr NeedScrnHack; LOCALVAR blnr NeedVidMem; LOCALFUNC tMyErr ChooseScreenOpts(void) { tMyErr err; err = kMyErr_noErr; if (! cur_mIIorIIX) { if (cur_hres * cur_vres > (uimr)2 * 1024 * 1024) { err = ReportParseFailure( "-hres and -vres multiplied must be < 2M"); } } if ((gbk_mdl_PB100 == cur_mdl) || cur_mIIorIIX) { NeedScrnHack = falseblnr; NeedVidMem = trueblnr; } else { NeedScrnHack = (cur_hres != dfo_hres()) || (cur_vres != dfo_vres()); NeedVidMem = NeedScrnHack; } return err; } LOCALVAR blnr EmVidCard; /* video memory size */ LOCALVAR uimr VidMemSize; LOCALFUNC tMyErr ChooseVidMemSize(void) { tMyErr err; EmVidCard = cur_mIIorIIX; VidMemSize = (((cur_hres * cur_vres) << cur_ScrnDpth) + 7) >> 3; --VidMemSize; VidMemSize |= (VidMemSize >> 1); VidMemSize |= (VidMemSize >> 2); VidMemSize |= (VidMemSize >> 4); VidMemSize |= (VidMemSize >> 8); VidMemSize |= (VidMemSize >> 16); ++VidMemSize; err = kMyErr_noErr; if (! NeedVidMem) { VidMemSize = 0; } else if (EmVidCard) { if (VidMemSize > 4 * 1024 * 1024) { err = ReportParseFailure( "video memory must be <= 4M"); } else if (VidMemSize <= 0x00008000) { VidMemSize = 0x00008000; } } else if (gbk_mdl_PB100 == cur_mdl) { VidMemSize = 0x00008000; } else { /* VidMemSize = 0x00020000; */ if (VidMemSize > 256 * 1024) { err = ReportParseFailure( "video memory must be <= 256K"); } else if (VidMemSize <= 0x00004000) { VidMemSize = 0x00004000; } } return err; } /* figure out what hardware to emulate */ LOCALVAR blnr EmClassicKbrd; LOCALVAR blnr EmADB; LOCALVAR blnr EmRTC; LOCALVAR blnr EmPMU; LOCALVAR blnr EmVIA2; LOCALVAR blnr EmASC; LOCALFUNC tMyErr ChooseMiscEmHardware(void) { EmClassicKbrd = cur_mdl <= gbk_mdl_Plus; if (EmClassicKbrd) { EmADB = falseblnr; EmRTC = trueblnr; EmPMU = falseblnr; } else if ((cur_mdl <= gbk_mdl_Classic) || cur_mIIorIIX) { EmADB = trueblnr; EmRTC = trueblnr; EmPMU = falseblnr; } else { EmADB = falseblnr; EmRTC = falseblnr; EmPMU = trueblnr; } EmVIA2 = cur_mIIorIIX; EmASC = (gbk_mdl_PB100 == cur_mdl) || cur_mIIorIIX; return kMyErr_noErr; } /* total memory size */ #define dbglog_buflnsz 18 #define kLn2SoundBuffers 4 /* kSoundBuffers must be a power of two */ #define kLnOneBuffLen 9 #define dbhBufferSize (((1UL << kLn2SoundBuffers) + 1UL) \ << (kLnOneBuffLen + cur_SoundSampSz - 3)) #define vMacScreenNumBytes ((((cur_hres * cur_vres) \ << cur_ScrnDpth) + 7) >> 3) LOCALVAR uimr TotMemSize; LOCALFUNC tMyErr ChooseTotMemSize(void) { TotMemSize = 0; if (DbgLogHAVE) { TotMemSize += (1 << dbglog_buflnsz); } /* CntrlDisplayBuff */ TotMemSize += vMacScreenNumBytes; /* screencomparebuff */ TotMemSize += vMacScreenNumBytes; if (1 != cur_MagFctr) { /* ScalingBuff */ TotMemSize += vMacScreenNumBytes * cur_MagFctr * cur_MagFctr; /* ScalingTabl */ TotMemSize += 256 * cur_MagFctr; } if (MySoundEnabled) { /* TheSoundBuffer */ TotMemSize += dbhBufferSize; } TotMemSize += (1 << RAMa_Size); if (0 != RAMb_Size) { TotMemSize += (1 << RAMb_Size); } if (EmVidCard) { TotMemSize += 0x000800; /* kVidROM_Size */ } if (NeedVidMem) { TotMemSize += VidMemSize; } TotMemSize += 512 * 1024UL; /* for M68KITAB */ return kMyErr_noErr; } /* ------ */ LOCALPROC SPResetCommandLineParameters(void) { ResetModelOption(); ResetHResOption(); ResetVResOption(); ResetScrnDpthOption(); ResetInitFullScreen(); ResetVarFullScreen(); ResetMagFctrOption(); ResetInitMagnify(); ResetSoundOption(); ResetSndApiOption(); ResetSoundSampSzOption(); ResetNumDrivesOption(); ResetSonySupportTags(); ResetSonyWantChecksumsUpdated(); ResetSonySupportDC42(); ResetSaveDialogEnable(); ResetInsertIthDisk(); ResetCmndOptSwap(); ResetKeyMapOption(); ResetEKTMapOption(); ResetAltKeysMode(); ResetItnlKyBdFixOption(); ResetLocalTalk(); ResetInitSpeedOption(); ResetInitBackground(); ResetInitAutoSlow(); ResetTimingAccuracyOption(); ResetEmCpuVersOption(); ResetMemSizOption(); ResetCaretBlinkTimeOption(); ResetDoubleClickTimeOption(); ResetMenuBlinkOption(); ResetAutoKeyThreshOption(); ResetAutoKeyRateOption(); ResetHilColRedOption(); ResetHilColGreenOption(); ResetHilColBlueOption(); ResetAutoLocation(); ResetInitLatitudeOption(); ResetInitLongitudeOption(); ResetAutoTimeZone(); ResetTzDST(); ResetTzDeltHOption(); ResetTzDeltSOption(); ResetSpeakerVolOption(); ResetWantMinExtn(); ResetMouseMotionOption(); ResetGrabKeysFS(); ResetEnblCtrlInt(); ResetEnblCtrlRst(); ResetEnblCtrlKtg(); ResetWantColorImage(); ResetAltHappyMacOption(); ResetRomSizeOption(); ResetCheckRomCheckSum(); ResetDisableRomCheck(); ResetDisableRamTest(); ResetWantDisasm(); ResetDbgLogHAVE(); ResetAbnormalReports(); ResetScreenVSync(); ResetGraphicsSwitching(); ResetSigning(); ResetSandbox(); } LOCALFUNC tMyErr TryAsSPOptionNot(void) { tMyErr err; if (kMyErrNoMatch == (err = TryAsModelOptionNot())) if (kMyErrNoMatch == (err = TryAsHResOptionNot())) if (kMyErrNoMatch == (err = TryAsVResOptionNot())) if (kMyErrNoMatch == (err = TryAsScrnDpthOptionNot())) if (kMyErrNoMatch == (err = TryAsInitFullScreenNot())) if (kMyErrNoMatch == (err = TryAsVarFullScreenNot())) if (kMyErrNoMatch == (err = TryAsMagFctrOptionNot())) if (kMyErrNoMatch == (err = TryAsInitMagnifyNot())) if (kMyErrNoMatch == (err = TryAsSoundOptionNot())) if (kMyErrNoMatch == (err = TryAsSndApiOptionNot())) if (kMyErrNoMatch == (err = TryAsSoundSampSzOptionNot())) if (kMyErrNoMatch == (err = TryAsNumDrivesOptionNot())) if (kMyErrNoMatch == (err = TryAsSonySupportTagsNot())) if (kMyErrNoMatch == (err = TryAsSonyWantChecksumsUpdatedNot())) if (kMyErrNoMatch == (err = TryAsSonySupportDC42Not())) if (kMyErrNoMatch == (err = TryAsSaveDialogEnable())) if (kMyErrNoMatch == (err = TryAsInsertIthDisk())) if (kMyErrNoMatch == (err = TryAsCmndOptSwapNot())) if (kMyErrNoMatch == (err = TryAsKeyMapOptionNot())) if (kMyErrNoMatch == (err = TryAsEKTMapOptionNot())) if (kMyErrNoMatch == (err = TryAsAltKeysModeNot())) if (kMyErrNoMatch == (err = TryAsItnlKyBdFixNot())) if (kMyErrNoMatch == (err = TryAsLocalTalkNot())) if (kMyErrNoMatch == (err = TryAsInitSpeedOptionNot())) if (kMyErrNoMatch == (err = TryAsInitBackgroundNot())) if (kMyErrNoMatch == (err = TryAsInitAutoSlowNot())) if (kMyErrNoMatch == (err = TryAsTimingAccuracyOptionNot())) if (kMyErrNoMatch == (err = TryAsEmCpuVersOptionNot())) if (kMyErrNoMatch == (err = TryAsMemSizOptionNot())) if (kMyErrNoMatch == (err = TryAsCaretBlinkTimeOptionNot())) if (kMyErrNoMatch == (err = TryAsDoubleClickTimeOptionNot())) if (kMyErrNoMatch == (err = TryAsMenuBlinkOptionNot())) if (kMyErrNoMatch == (err = TryAsAutoKeyThreshOptionNot())) if (kMyErrNoMatch == (err = TryAsAutoKeyRateOptionNot())) if (kMyErrNoMatch == (err = TryAsHilColRedOptionNot())) if (kMyErrNoMatch == (err = TryAsHilColGreenOptionNot())) if (kMyErrNoMatch == (err = TryAsHilColBlueOptionNot())) if (kMyErrNoMatch == (err = TryAsAutoLocationNot())) if (kMyErrNoMatch == (err = TryAsInitLatitudeOptionNot())) if (kMyErrNoMatch == (err = TryAsInitLongitudeOptionNot())) if (kMyErrNoMatch == (err = TryAsAutoTimeZoneNot())) if (kMyErrNoMatch == (err = TryAsTzDSTNot())) if (kMyErrNoMatch == (err = TryAsTzDeltHOptionNot())) if (kMyErrNoMatch == (err = TryAsTzDeltSOptionNot())) if (kMyErrNoMatch == (err = TryAsSpeakerVolOptionNot())) if (kMyErrNoMatch == (err = TryAsWantMinExtnNot())) if (kMyErrNoMatch == (err = TryAsMouseMotionOptionNot())) if (kMyErrNoMatch == (err = TryAsGrabKeysFSNot())) if (kMyErrNoMatch == (err = TryAsEnblCtrlIntNot())) if (kMyErrNoMatch == (err = TryAsEnblCtrlRstNot())) if (kMyErrNoMatch == (err = TryAsEnblCtrlKtgNot())) if (kMyErrNoMatch == (err = TryAsWantColorImageNot())) if (kMyErrNoMatch == (err = TryAsAltHappyMacOptionNot())) if (kMyErrNoMatch == (err = TryAsRomSizeOptionNot())) if (kMyErrNoMatch == (err = TryAsCheckRomCheckSumNot())) if (kMyErrNoMatch == (err = TryAsDisableRomCheckNot())) if (kMyErrNoMatch == (err = TryAsDisableRamTestNot())) if (kMyErrNoMatch == (err = TryAsWantDisasmNot())) if (kMyErrNoMatch == (err = TryAsDbgLogHAVENot())) if (kMyErrNoMatch == (err = TryAsAbnormalReportsNot())) if (kMyErrNoMatch == (err = TryAsScreenVSyncNot())) if (kMyErrNoMatch == (err = TryAsGraphicsSwitchingNot())) if (kMyErrNoMatch == (err = TryAsSigningNot())) if (kMyErrNoMatch == (err = TryAsSandboxNot())) { } return err; } LOCALFUNC tMyErr AutoChooseSPSettings(void) { tMyErr err; if (kMyErr_noErr == (err = ChooseModel())) if (kMyErr_noErr == (err = ChooseHRes())) if (kMyErr_noErr == (err = ChooseVRes())) if (kMyErr_noErr == (err = ChooseScrnDpth())) if (kMyErr_noErr == (err = ChooseInitFullScreen())) if (kMyErr_noErr == (err = ChooseVarFullScreen())) if (kMyErr_noErr == (err = ChooseMagFctr())) if (kMyErr_noErr == (err = ChooseInitMagnify())) if (kMyErr_noErr == (err = ChooseSoundEnabled())) if (kMyErr_noErr == (err = ChooseSndApiOption())) if (kMyErr_noErr == (err = ChooseSoundSampSz())) if (kMyErr_noErr == (err = ChooseNumDrives())) if (kMyErr_noErr == (err = ChooseSonySupportTags())) if (kMyErr_noErr == (err = ChooseSonyWantChecksumsUpdated())) if (kMyErr_noErr == (err = ChooseSonySupportDC42())) if (kMyErr_noErr == (err = ChooseSaveDialogEnable())) if (kMyErr_noErr == (err = ChooseInsertIthDisk())) if (kMyErr_noErr == (err = ChooseCmndOptSwap())) if (kMyErr_noErr == (err = ChooseKeyMap())) if (kMyErr_noErr == (err = ChooseEKTMap())) if (kMyErr_noErr == (err = ChooseAltKeysMode())) if (kMyErr_noErr == (err = ChooseItnlKyBdFix())) if (kMyErr_noErr == (err = ChooseLocalTalk())) if (kMyErr_noErr == (err = ChooseInitSpeed())) if (kMyErr_noErr == (err = ChooseInitBackground())) if (kMyErr_noErr == (err = ChooseInitAutoSlow())) if (kMyErr_noErr == (err = ChooseTimingAccuracy())) if (kMyErr_noErr == (err = ChooseEmCpuVers())) if (kMyErr_noErr == (err = ChooseMemSiz())) if (kMyErr_noErr == (err = ChooseMemBankSizes())) /* derived */ if (kMyErr_noErr == (err = ChooseCaretBlinkTime())) if (kMyErr_noErr == (err = ChooseDoubleClickTime())) if (kMyErr_noErr == (err = ChooseMenuBlink())) if (kMyErr_noErr == (err = ChooseAutoKeyThresh())) if (kMyErr_noErr == (err = ChooseAutoKeyRate())) if (kMyErr_noErr == (err = ChooseHilColRed())) if (kMyErr_noErr == (err = ChooseHilColGreen())) if (kMyErr_noErr == (err = ChooseHilColBlue())) if (kMyErr_noErr == (err = ChooseAutoLocation())) if (kMyErr_noErr == (err = ChooseInitLatitude())) if (kMyErr_noErr == (err = ChooseInitLongitude())) if (kMyErr_noErr == (err = ChooseAutoTimeZone())) if (kMyErr_noErr == (err = ChooseTzDST())) /* if (kMyErr_noErr == (err = ChooseTzDeltH())) */ if (kMyErr_noErr == (err = ChooseTzDeltS())) if (kMyErr_noErr == (err = ChooseSpeakerVol())) if (kMyErr_noErr == (err = ChooseWantMinExtn())) if (kMyErr_noErr == (err = ChooseMouseMotion())) if (kMyErr_noErr == (err = ChooseGrabKeysFS())) if (kMyErr_noErr == (err = ChooseEnblCtrlInt())) if (kMyErr_noErr == (err = ChooseEnblCtrlRst())) if (kMyErr_noErr == (err = ChooseEnblCtrlKtg())) if (kMyErr_noErr == (err = ChooseWantColorImage())) if (kMyErr_noErr == (err = ChooseAltHappyMac())) if (kMyErr_noErr == (err = ChooseRomSize())) if (kMyErr_noErr == (err = ChooseCheckRomCheckSum())) if (kMyErr_noErr == (err = ChooseDisableRomCheck())) if (kMyErr_noErr == (err = ChooseDisableRamTest())) if (kMyErr_noErr == (err = ChooseWantDisasm())) if (kMyErr_noErr == (err = ChooseDbgLogHAVE())) if (kMyErr_noErr == (err = ChooseAbnormalReports())) if (kMyErr_noErr == (err = ChooseScreenVSync())) if (kMyErr_noErr == (err = ChooseGraphicsSwitching())) if (kMyErr_noErr == (err = ChooseSigning())) if (kMyErr_noErr == (err = ChooseSandbox())) if (kMyErr_noErr == (err = ChooseScreenOpts())) /* derived */ if (kMyErr_noErr == (err = ChooseVidMemSize())) /* derived */ if (kMyErr_noErr == (err = ChooseMiscEmHardware())) /* derived */ if (kMyErr_noErr == (err = ChooseTotMemSize())) /* derived */ { err = kMyErr_noErr; } return err; } LOCALPROC WrtOptSPSettings(void) { WrtOptModelOption(); WrtOptHResOption(); WrtOptVResOption(); WrtOptScrnDpth(); WrtOptInitFullScreen(); WrtOptVarFullScreen(); WrtOptMagFctrOption(); WrtOptInitMagnify(); WrtOptSoundOption(); WrtOptSndApiOption(); WrtOptSoundSampSzOption(); WrtOptNumDrivesOption(); WrtOptSonySupportTags(); WrtOptSonyWantChecksumsUpdated(); WrtOptSonySupportDC42(); WrtOptSaveDialogEnable(); WrtOptInsertIthDisk(); WrtOptCmndOptSwap(); WrtOptKeyMap(); WrtOptEKTMap(); WrtOptAltKeysMode(); WrtOptItnlKyBdFix(); WrtOptLocalTalk(); WrtOptInitSpeedOption(); WrtOptInitBackground(); WrtOptInitAutoSlow(); WrtOptTimingAccuracy(); WrtOptEmCpuVers(); WrtOptMemSizOption(); WrtOptCaretBlinkTime(); WrtOptDoubleClickTime(); WrtOptMenuBlink(); WrtOptAutoKeyThresh(); WrtOptAutoKeyRate(); WrtOptHilColRed(); WrtOptHilColGreen(); WrtOptHilColBlue(); WrtOptAutoLocation(); WrtOptInitLatitude(); WrtOptInitLongitude(); WrtOptAutoTimeZone(); WrtOptTzDST(); /* WrtOptTzDeltH(); */ WrtOptTzDeltS(); WrtOptSpeakerVol(); WrtOptMinExtn(); WrtOptMouseMotion(); WrtOptGrabKeysFS(); WrtOptEnblCtrlInt(); WrtOptEnblCtrlRst(); WrtOptEnblCtrlKtg(); WrtOptColorImage(); WrtOptAltHappyMac(); WrtOptRomSize(); WrtOptCheckRomCheckSum(); WrtOptDisableRomCheck(); WrtOptDisableRamTest(); WrtOptWantDisasmNot(); WrtOptDbgLogHAVE(); WrtOptAbnormalReports(); WrtOptScreenVSync(); WrtOptGraphicsSwitching(); WrtOptSigning(); WrtOptSandbox(); }