home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 March / macformat-022.iso / Shareware City / Science / µSim 1.0b5 folder / source / DoMenu.c < prev    next >
Encoding:
Text File  |  1994-09-01  |  12.0 KB  |  518 lines  |  [TEXT/MMCC]
  1. /*
  2. Copyright © 1993,1994 by Fabrizio Oddone
  3. ••• ••• ••• ••• ••• ••• ••• ••• ••• •••
  4. This source code is distributed as freeware: you can copy, exchange, modify this
  5. code as you wish. You may include this code in any kind of application: freeware,
  6. shareware, or commercial, provided that full credits are given.
  7. You may not sell or distribute this code for profit.
  8. */
  9.  
  10. //#pragma load "MacDump"
  11.  
  12. #include    "UtilsSys7.h"
  13. #include    "Globals.h"
  14. #include    "Animation.h"
  15. #include    "Assembler.h"
  16. #include    "ControlStore.h"
  17. #include    "Disasm.h"
  18. #include    "DoMenu.h"
  19. #include    "Dump.h"
  20. #include    "Input.h"
  21. #include    "Main.h"
  22. #include    "Microprogram_Ed.h"
  23. #include    "myMemory.h"
  24. #include    "Preferences.h"
  25. #include    "Registers.h"
  26. #include    "Simulator.h"
  27. #include    "SimUtils.h"
  28.  
  29. #if defined(FabSystem7orlater)
  30.  
  31. //#pragma segment Main
  32.  
  33. short lastCommand = kST_STOPPED;
  34.  
  35. static void DoMenuApple(short theItem);
  36. static void DoMenuEdit(short theItem);
  37. static void DoMenuMemory(short theItem);
  38. static void DoMenuRegs(short theItem);
  39. static void DoMenuHDisasm(short theItem);
  40. static void DoMenuHDump(short theItem);
  41. static void DoMenuControl(short theItem);
  42. static void CompletePreviousInstruction(void);
  43. static void DoMenuAssembler(short theItem);
  44.  
  45. void DoMenuApple(short theItem)
  46. {
  47. Str255    DAName;
  48.  
  49. if (theItem == kMItem_About__Simulato) {
  50.     myAbout(DoIdle, nil, DoUpdate, DoActivate);
  51.     UnloadSeg(myAbout);
  52.     }
  53. else {
  54.     GetItem(gMenu_Apple, theItem, DAName);
  55.     (void)OpenDeskAcc(DAName);
  56.     }
  57. }
  58.  
  59. void DoMenuFile(short theItem)
  60. {
  61. register OSErr    err;
  62.  
  63. switch (theItem) {
  64.     case kMItem_New:
  65.         if (ReadyToTerminate()) {
  66.             DoNew();
  67.             UnloadSeg(DoNew);
  68.             DoMenuWindows(kMItem_Microprogram);
  69.             }
  70.         break;
  71.     case kMItem_Open_Control_St: {
  72.         StandardFileReply    mySFR;
  73.         SFTypeList    myTypeList;
  74.  
  75.         if (ReadyToTerminate()) {
  76.             myTypeList[0] = kFTY_CSTORE;
  77.             StandardGetFile(0L, 1, myTypeList, &mySFR);
  78.             if (mySFR.sfGood) {
  79.                 err = myOpenCSFile(&mySFR.sfFile, mySFR.sfScript,
  80.                                         (mySFR.sfFlags & kfIsStationery) != 0);
  81.                 UnloadSeg(myOpenCSFile);
  82.                 if (err)
  83.                     ErrorAlert(err);
  84.                 }
  85.             }
  86.         }
  87.         break;
  88.     case kMItem_Close:
  89.         (void)ReadyToTerminate();
  90.         break;
  91.     case kMItem_Save_Control_St:
  92.         err = mySaveCSFile(kGOT_SAVE);
  93.         UnloadSeg(mySaveCSFile);
  94.         if (err)
  95.             if (err != 1)
  96.                 ErrorAlert(err);
  97.         break;
  98.     case kMItem_Save_Control_St2:
  99.         err = mySaveCSFile(kGOT_SAVEAS);
  100.         UnloadSeg(mySaveCSFile);
  101.         if (err)
  102.             if (err != 1)
  103.                 ErrorAlert(err);
  104.         break;
  105.     case kMItem_Revert_to_Saved:
  106.         InitCursor();
  107.         if (CautionAlert_UPP(kALRT_REVERT, myStdFilterProc) == ok) {
  108.             err = RevertFile();
  109.             UnloadSeg(RevertFile);
  110.             if (err)
  111.                 ErrorAlert(err);
  112.             }
  113.         break;
  114. /*    case kMItem_Page_Setup:
  115.         PageSetup();
  116.         UnloadSeg(PageSetup);
  117.         break;
  118.     case kMItem_Print:
  119.         Print_The_Data();
  120.         UnloadSeg(Print_The_Data);
  121.         break;*/
  122.     case kMItem_Prefs:
  123.         Preferences();
  124.         UnloadSeg(Preferences);
  125.         break;
  126.     case kMItem_Quit:
  127.         if (ReadyToTerminate())
  128.             gDoneFlag = true;
  129.         break;
  130.     }
  131. }
  132.  
  133. void DoMenuEdit(short theItem)
  134. {
  135. register Ptr    scPtr;
  136. register union u_mir *scanPtr;
  137. register union u_mir    tmpmir;
  138. register OSErr    err;
  139. register Byte    val;
  140.  
  141. if (SystemEdit(theItem - 1) == false) {
  142.     switch (theItem) {
  143.         case kMItem_Undo:
  144. /* not implemented yet */
  145.             break;
  146.         case kMItem_Cut:
  147.             if (gTheInput) {
  148.                 TECut(gTheInput);
  149.                 if (gWPtr_Microprogram_Ed == FrontWindow())
  150.                     Microprog_TextWasModified();
  151.                 else if (gWPtr_IO == FrontWindow())
  152.                     AdjustScrollbars(gWPtr_IO, false);
  153.                 if ((err = ZeroScrap()) == noErr)
  154.                     err = TEToScrap();
  155.                 if (err)
  156.                     ErrorAlert(err);
  157.                 }
  158.             else if ((gWPtr_Microprogram_Ed == FrontWindow()) &&
  159.                         (keyDownDest == kKEY_LIST))
  160.                 if (err = SendClipMsg(kCLIPMSG_CUT))
  161.                     ErrorAlert(err);
  162.             break;
  163.  
  164.         case kMItem_Copy:
  165.             if (gTheInput != 0L) {
  166.                 TECopy(gTheInput);
  167.                 if ((err = ZeroScrap()) == noErr)
  168.                     err = TEToScrap();
  169.                 if (err)
  170.                     ErrorAlert(err);
  171.                 }
  172.             else if ((gWPtr_Microprogram_Ed == FrontWindow()) &&
  173.                         (keyDownDest == kKEY_LIST))
  174.                 if (err = SendClipMsg(kCLIPMSG_COPY))
  175.                     ErrorAlert(err);
  176.             break;
  177.  
  178.         case kMItem_Paste:
  179.             if (gTheInput != 0L) {
  180.                 TEPaste(gTheInput);
  181.                 if (gWPtr_Microprogram_Ed == FrontWindow())
  182.                     Microprog_TextWasModified();
  183.                 else if (gWPtr_IO == FrontWindow())
  184.                     AdjustScrollbars(gWPtr_IO, false);
  185.                 }
  186.             else if ((gWPtr_Microprogram_Ed == FrontWindow()) &&
  187.                         (keyDownDest == kKEY_LIST))
  188.                 if (err = SendClipMsg(kCLIPMSG_PASTE))
  189.                     ErrorAlert(err);
  190.             break;
  191.  
  192.         case kMItem_Clear:
  193.             if (gTheInput != 0L) {
  194.                 TEDelete(gTheInput);
  195.                 if (gWPtr_Microprogram_Ed == FrontWindow())
  196.                     Microprog_TextWasModified();
  197.                 else if (gWPtr_IO == FrontWindow())
  198.                     AdjustScrollbars(gWPtr_IO, false);
  199.                 }
  200.             else if ((gWPtr_Microprogram_Ed == FrontWindow()) &&
  201.                         (keyDownDest == kKEY_LIST))
  202.                 if (err = SendClipMsg(kCLIPMSG_CLEAR))
  203.                     ErrorAlert(err);
  204.             break;
  205.         case kMItem_Select_All:
  206.             if (gTheInput != 0L)
  207.                 TESetSelect(0, 32767, gTheInput);
  208.             break;
  209.         case kMItem_Insert:
  210. //            LDoDraw(false, Lists[kL_COMMENTS]);
  211.             BlockMoveData(gCsMemory + theSelection[kL_COMMENTS],
  212.                 gCsMemory + theSelection[kL_COMMENTS] + 1,
  213.                 sizeof(union u_mir)*(maxLLine[kL_COMMENTS] - theSelection[kL_COMMENTS]));
  214.             gCsMemory[theSelection[kL_COMMENTS]].cstore = 0L;
  215.             for (scanPtr = gCsMemory; scanPtr < (gCsMemory + maxLLine[kL_COMMENTS]);
  216.                     tmpmir = *scanPtr++)
  217.                 if (tmpmir.bits.addr >= theSelection[kL_COMMENTS])
  218.                     if (tmpmir.bits.addr != 0x7F) { /* WARNING: non-portable form */
  219.                         tmpmir.bits.addr++;
  220.                         *(scanPtr - 1) = tmpmir;
  221.                         }
  222.             for (scPtr = gAssMemory; scPtr < (gAssMemory + kSIZE_ASSMEM); val = *scPtr++)
  223.                 if (val >= theSelection[kL_COMMENTS]) {
  224.                     val++;
  225.                     *(scPtr - 1) = val;
  226.                     }
  227.             LDelRow(1, maxLLine[kL_COMMENTS], Lists[kL_COMMENTS]);
  228.             LAddRow(1, theSelection[kL_COMMENTS]++, Lists[kL_COMMENTS]);
  229.             DocumentIsDirty(true);
  230. //            LDoDraw(true, Lists[kL_COMMENTS]);
  231.             LAutoScroll(Lists[kL_COMMENTS]);
  232.             break;
  233.         case kMItem_Delete:
  234. //            LDoDraw(false, Lists[kL_COMMENTS]);
  235.             for (scanPtr = gCsMemory; scanPtr < (gCsMemory + maxLLine[kL_COMMENTS]);
  236.                     tmpmir = *scanPtr++)
  237.                 if (tmpmir.bits.addr >= theSelection[kL_COMMENTS])
  238.                     if (tmpmir.bits.addr) {
  239.                         tmpmir.bits.addr--;
  240.                         *(scanPtr - 1) = tmpmir;
  241.                         }
  242.             for (scPtr = gAssMemory; scPtr < (gAssMemory + kSIZE_ASSMEM); val = *scPtr++)
  243.                 if (val > theSelection[kL_COMMENTS]) {
  244.                     val--;
  245.                     *(scPtr - 1) = val;
  246.                     }
  247.             SelectLLine(kL_COMMENTS, theSelection[kL_COMMENTS] + 1);
  248.             BlockMoveData(gCsMemory + theSelection[kL_COMMENTS],
  249.                 gCsMemory + theSelection[kL_COMMENTS] - 1,
  250.                 sizeof(union u_mir)*(maxLLine[kL_COMMENTS] - theSelection[kL_COMMENTS] + 1));
  251.             gCsMemory[maxLLine[kL_COMMENTS]].cstore = 0L;
  252.             LDelRow(1, --theSelection[kL_COMMENTS], Lists[kL_COMMENTS]);
  253.             LAddRow(1, maxLLine[kL_COMMENTS], Lists[kL_COMMENTS]);
  254.             DocumentIsDirty(true);
  255. //            LDoDraw(true, Lists[kL_COMMENTS]);
  256.             LAutoScroll(Lists[kL_COMMENTS]);
  257.             break;
  258.         }
  259.     }
  260. }
  261.  
  262. void DoMenuWindows(short theItem)
  263. {
  264. register WindowPtr    wind;
  265.  
  266. switch (theItem) {
  267.     case kMItem_Animation:
  268.         wind = gWPtr_Animation;
  269.         break;
  270.     case kMItem_Registers:
  271.         wind = gWPtr_Registers;
  272.         break;
  273.     case kMItem_IO:
  274.         wind = gWPtr_IO;
  275.         break;
  276.     case kMItem_Microprogram:
  277.         PrepareOpenMicroprogram();
  278.         wind = gWPtr_Microprogram_Ed;
  279.         break;
  280.     case kMItem_Disasm:
  281.         wind = gWPtr_Disasm;
  282.         break;
  283.     case kMItem_Dump:
  284.         wind = gWPtr_Dump;
  285.         break;
  286.     }
  287. ShowWindowAndCheckMenu(wind, theItem);
  288. SelectWindow(wind);
  289. }
  290.  
  291. void ShowWindowAndCheckMenu(WindowPtr w, short theMenuItem)
  292. {
  293. if (((WindowPeek)w)->visible == false) {
  294.     CheckItem(gMenu_Windows, theMenuItem, true);
  295.     SetPort(w);
  296.     ShowWindow(w);
  297.     }
  298. }
  299.  
  300. void DoMenuMemory(short theItem)
  301. {
  302. register OSErr    err;
  303.  
  304. switch (theItem) {
  305.     case kMItem_Open: {
  306.         StandardFileReply    mySFR;
  307.         SFTypeList    myTypeList;
  308.  
  309.         myTypeList[0] = kFTY_RAM;
  310.         StandardGetFile(0L, 1, myTypeList, &mySFR);
  311.         if (mySFR.sfGood) {
  312.             if (err = myOpenFile(&mySFR.sfFile, gMMemory, kSIZE_RAM))
  313.                 ErrorAlert(err);
  314.             UnloadSeg(myOpenFile);
  315.             }
  316.         }
  317.         break;
  318.     case kMItem_Save_As:
  319.         if (err = mySaveFile(gMMemory, kSIZE_RAM, kFTY_RAM, kSTR_RAMPROMPT, kSTR_RAMDEFNAME))
  320.             ErrorAlert(err);
  321.         UnloadSeg(mySaveFile);
  322.         break;
  323.     }
  324. }
  325.  
  326. void    DoMenuRegs(short theItem)
  327. {
  328. register OSErr    err;
  329.  
  330. switch (theItem) {
  331.     case kMItem_Open: {
  332.         StandardFileReply    mySFR;
  333.         SFTypeList    myTypeList;
  334.  
  335.         myTypeList[0] = kFTY_REG;
  336.         StandardGetFile(0L, 1, myTypeList, &mySFR);
  337.         if (mySFR.sfGood) {
  338.             if (err = OpenProcessorState(&mySFR.sfFile))
  339.                 ErrorAlert(err);
  340.             UnloadSeg(OpenProcessorState);
  341.             }
  342.         }
  343.         break;
  344.     case kMItem_Save_As:
  345.         if (err = SaveProcessorState())
  346.             ErrorAlert(err);
  347.         UnloadSeg(SaveProcessorState);
  348.         break;
  349.     }
  350. }
  351.  
  352. static void    DoMenuHDisasm(short theItem)
  353. {
  354. SetCtlValue(disasmVScroll, (unsigned short)gRegs[theItem - 1] >> 1);
  355. InvalDisasm();
  356. }
  357.  
  358. static void    DoMenuHDump(short theItem)
  359. {
  360. SetCtlValue(dumpVScroll, (unsigned short)gRegs[theItem - 1] >> 3);
  361. InvalDump();
  362. }
  363.  
  364. /* da schiaffare dentro la routine successiva */
  365. const short toDeact[] = {    kP_MPC2INC, kP_INCR, kP_MPC2CST, kP_CST2MIR,
  366.                             kP_REG2LTCH1, kP_REG2LTCH2, kP_ALATCH, kP_BLATCH,
  367.                             kP_AMUX2ALU, kP_BLTCH2ALU, kP_ALU, kP_ALU2SH,
  368.                             kP_SHIFTER, kP_SH2REGS1, kP_SH2REGS2, kP_SH2REGS3,
  369.                             kP_MAR, kP_BLTCH2MAR1, kP_BLTCH2MAR2,
  370.                             kP_MBR, kP_SH2MBR1, kP_SH2MBR2, kP_MAP, kP_MAPREGS,
  371.                             kP_ALTCH2AMUX, kP_AMUX, kP_MBR2AMUX,
  372.                             kP_INC2MMUX1, kP_INC2MMUX2, kP_MMUX, kP_MPC,
  373.                             kC_ADDR1, kC_ADDR2, kP_MMUX2MPC, 0 };
  374.  
  375. void DoMenuControl(short theItem)
  376. {
  377. enum resetalerts {
  378. kALRT_RESETMEM = 128,
  379. kALRT_RESETREGS = 139
  380. };
  381.  
  382. short lastCommand = kST_STOPPED;
  383. register OSErr    err;
  384.  
  385. switch (theItem) {
  386.     case kMItem_Go:
  387.         gRstatus = kST_GOING;
  388.         CompletePreviousInstruction();
  389.         lastCommand = kST_GOING;
  390.         break;
  391.     case kMItem_Stop:
  392.         StopIt();
  393.         lastCommand = kST_STOPPED;
  394.         break;
  395.     case kMItem_StepSub:
  396.         gRstatus = kST_STEPSUBCYC;
  397.         if (lastCommand != kST_STEPSUBCYC) {
  398.             DeactivateObjs(toDeact);
  399.             lastCommand = kST_STEPSUBCYC;
  400.             }
  401.         break;
  402.     case kMItem_StepMicro:
  403.         gRstatus = kST_STEPMPROG;
  404.         lastCommand = kST_STEPMPROG;
  405.         break;
  406.     case kMItem_StepInstr:
  407.         gRstatus = kST_STEPASM;
  408.         CompletePreviousInstruction();
  409.         lastCommand = kST_STEPASM;
  410.         break;
  411.     case kMItem_ResetMem:
  412.         InitCursor();
  413.         if ((err = CautionAlert_UPP(kALRT_RESETMEM, myStdFilterProc)) == ok) {
  414.             MyZeroBuffer((long *)gMMemory, numOfLongs(kSIZE_RAM));
  415.             ResetMemory();
  416.             InvalDump();
  417.             InvalDisasm();
  418.             }
  419.         break;
  420.     case kMItem_ResetRegs:
  421.         InitCursor();
  422.         if ((err = CautionAlert_UPP(kALRT_RESETREGS, myStdFilterProc)) == ok) {
  423.             ResetRegisters();
  424.             UnloadSeg(ResetRegisters);
  425.             ChangedRegister(kREG_PC);
  426.             ChangedRegister(kREG_SP);
  427.             ChangedBox(kP_MPC - kFIRST_PICT);
  428.             }
  429.         break;
  430.     case kMItem_SelectCurMPC:
  431.         SelectLLine(kL_COMMENTS, gParts[kP_MPC - kFIRST_PICT]);
  432.         DoMenuWindows(kMItem_Microprogram);
  433.         break;
  434.     }
  435. }
  436.  
  437. /* CompletePreviousInstruction: keeps in sync the processor when
  438. alternating different step modes with continuous execution */
  439.  
  440. static void CompletePreviousInstruction(void)
  441. {
  442. while (gSubclk) {
  443.     ExecuteInstructions(gSubclk++);
  444.     gSubclk &= 3;
  445.     }
  446. }
  447.  
  448. void DoMenuAssembler(short theItem)
  449. {
  450. register OSErr    err;
  451.  
  452. switch (theItem) {
  453.     case kMItem_Assemble_file: {
  454.         StandardFileReply    mySFR;
  455.         SFTypeList    myTypeList;
  456.  
  457.         myTypeList[0] = 'TEXT';
  458.         StandardGetFile(0L, 1, myTypeList, &mySFR);
  459.         if (mySFR.sfGood) {
  460.             if (err = myAsmFile(&mySFR.sfFile))
  461.                 ErrorAlert(err);
  462.             UnloadSeg(myAsmFile);
  463.             }
  464.         }
  465.         break;
  466.     case kMItem_AsmPrefs:
  467.         DoAsmPrefsDialog();
  468.         UnloadSeg(DoAsmPrefsDialog);
  469.         break;
  470.     }
  471. }
  472.  
  473. void Handle_My_Menu(long myMenu)
  474. {
  475. register short    theMenu, theItem;
  476.  
  477. theMenu = HiWrd(myMenu);
  478. if (theMenu) {
  479.     theItem = LoWrd(myMenu);
  480.     switch (theMenu) {
  481.         case kRes_Menu_HMemory:
  482.             DoMenuMemory(theItem);
  483.             break;
  484.         case kRes_Menu_HRegs:
  485.             DoMenuRegs(theItem);
  486.             break;
  487.         case kRes_Menu_HDisasm:
  488.             DoMenuHDisasm(theItem);
  489.             break;
  490.         case kRes_Menu_HDump:
  491.             DoMenuHDump(theItem);
  492.             break;
  493.         case kRes_Menu_Apple:
  494.             DoMenuApple(theItem);
  495.             break;
  496.         case kRes_Menu_File:
  497.             DoMenuFile(theItem);
  498.             break;
  499.         case kRes_Menu_Edit:
  500.             DoMenuEdit(theItem);
  501.             break;
  502.         case kRes_Menu_Windows:
  503.             DoMenuWindows(theItem);
  504.             break;
  505.         case kRes_Menu_Control:
  506.             DoMenuControl(theItem);
  507.             break;
  508.         case kRes_Menu_Assembler:
  509.             DoMenuAssembler(theItem);
  510.             break;
  511.         }
  512.     }
  513. HiliteMenu(0);
  514. }
  515.  
  516. #endif
  517.  
  518.