home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 9 Archive / 09-Archive.zip / unzip532.zip / mac / macunzip.c < prev    next >
C/C++ Source or Header  |  1997-10-14  |  21KB  |  734 lines
  1. #define UNZIP_INTERNAL
  2. #include "unzip.h"
  3. #include "version.h"
  4.  
  5. #include <Traps.h>
  6. #ifdef THINK_C
  7. #include <Values.h>
  8. #endif
  9.  
  10. char UnzipVersion[32], ZipinfoVersion[32];
  11.  
  12. #define aboutAlert      128
  13.  
  14. #define selectDialog    129
  15. #define okItem          1
  16. #define cancelItem      2
  17. #define editItem        3
  18. #define staticItem      4
  19.  
  20. #define unzipMenuBar    128
  21.  
  22. #define appleMenu       128
  23. #define aboutItem       1
  24.  
  25. #define fileMenu        129
  26. #define extractItem     1
  27. #define infoItem        2
  28. #define listItem        3
  29. #define testItem        4
  30. #define commentItem     6
  31. #define freshenItem     8
  32. #define updateItem      9
  33. #define quitItem        11
  34.  
  35. #define editMenu        130
  36. #define cutItem         1
  37. #define copyItem        2
  38. #define pasteItem       3
  39.  
  40. #define modifierMenu    131
  41. #define excludeItem     1
  42. #define selectItem      2
  43. #define quietItem       9
  44. #define verboseItem     10
  45.  
  46. #define screenMenu      132
  47. #define pauseItem       1
  48. #define scrollItem      2
  49.  
  50. #define extractMenu     133
  51. #define screenItem      3
  52. #define junkItem        5
  53.  
  54. #define caseMenu        134
  55. #define insensitiveItem 1
  56. #define lowercaseItem   2
  57.  
  58. #define convertMenu     135
  59. #define autoItem        1
  60. #define binaryItem      2
  61. #define textItem        3
  62.  
  63. #define overwriteMenu   136
  64. #define alwaysItem      1
  65. #define neverItem       2
  66. #define promptItem      3
  67.  
  68. #define infoMenu        137
  69. #define prtCommentItem  2
  70. #define prtHeaderItem   3
  71. #define prtTotalsItem   4
  72.  
  73. #define formatMenu      138
  74. #define filenameItem    1
  75. #define longItem        2
  76. #define mediumItem      3
  77. #define shortItem       4
  78.  
  79. long modifiers, modifierMask;
  80.  
  81. #define allFlags        0x000FFFFF
  82.  
  83. #define quietFlag       0x00000001
  84. #define verboseFlag     0x00000002
  85.  
  86. #define pauseFlag       0x00080000
  87. #define scrollFlag      0x00040000
  88.  
  89. #define screenFlag      0x00000004
  90. #define junkFlag        0x00000008
  91.  
  92. #define insensitiveFlag 0x00000010
  93. #define lowercaseFlag   0x00000020
  94.  
  95. #define autoFlag        0x00000040
  96. #define textFlag        0x00000080
  97.  
  98. #define neverFlag       0x00000100
  99. #define overwriteFlag   0x00000200
  100.  
  101. #define prtCommentFlag  0x00000400
  102. #define prtHeaderFlag   0x00000800
  103. #define prtTotalsFlag   0x00001000
  104.  
  105. #define filenameFlag    0x00002000
  106. #define longFlag        0x00004000
  107. #define mediumFlag      0x00008000
  108. #define shortFlag       0x00010000
  109.  
  110. #define extractMask     0x000003FD
  111. #define infoMask        0x0001FE02
  112. #define listMask        0x00000001
  113. #define testMask        0x00000001
  114. #define commentMask     0x00000000
  115. #define freshenMask     0x000003FD
  116. #define updateMask      0x000003FD
  117.  
  118. EventRecord myevent;
  119. MenuHandle appleHandle, modifierHandle, screenHandle, extractHandle;
  120. MenuHandle caseHandle, convertHandle, overwriteHandle, infoHandle;
  121. MenuHandle formatHandle;
  122. Handle menubar, itemHandle;
  123. short itemType;
  124. Rect itemRect;
  125.  
  126. char command, fileList[256];
  127.  
  128. Boolean stop;
  129.  
  130. SysEnvRec sysRec;
  131.  
  132. char *macgetenv(s) char *s; {
  133.     if (s == NULL) return(fileList);
  134.     return(NULL);
  135. }
  136.  
  137. static Boolean TrapAvailable(machineType, trapNumber, trapType)
  138. short machineType;
  139. short trapNumber;
  140. TrapType trapType;
  141. {
  142.     if (machineType < 0)
  143.         return (false);
  144.  
  145.     if ((trapType == ToolTrap) &&
  146.         (machineType > envMachUnknown) &&
  147.         (machineType < envMacII)) {
  148.         if ((trapNumber &= 0x03FF) > 0x01FF)
  149.             trapNumber = _Unimplemented;
  150.     }
  151.     return (NGetTrapAddress(trapNumber, trapType) !=
  152. #ifdef __MWERKS__
  153.         NGetTrapAddress(_Unimplemented, trapType));
  154. #else
  155.         GetTrapAddress(_Unimplemented));
  156. #endif
  157. }
  158.  
  159. static void domenu(menucommand) long menucommand;
  160. {
  161.     short themenu, theitem;
  162.     DialogPtr thedialog;
  163.     Str255 name;
  164.     long check;
  165.  
  166.     themenu = HiWord(menucommand);
  167.     theitem = LoWord(menucommand);
  168.  
  169.     switch (themenu) {
  170.  
  171.     case appleMenu:
  172.         if (theitem == aboutItem) {
  173.             ParamText((StringPtr)UnzipVersion, (StringPtr)ZipinfoVersion, nil, nil);
  174.             Alert(aboutAlert, nil);
  175.         } else {
  176.             GetItem(appleHandle, theitem, name);
  177.             theitem = OpenDeskAcc(name);
  178.         }
  179.         break;
  180.  
  181.     case fileMenu:
  182.         switch (theitem) {
  183.         case extractItem:
  184.             if (modifiers & screenFlag)
  185.                 command = 'c';
  186.             else
  187.                 command = 'x';
  188.             modifierMask = extractMask;
  189.             break;
  190.         case infoItem:
  191.             command = 'Z';
  192.             modifierMask = infoMask;
  193.             break;
  194.         case listItem:
  195.             if (modifiers & verboseFlag)
  196.                 command = 'v';
  197.             else
  198.                 command = 'l';
  199.             modifierMask = listMask;
  200.             break;
  201.         case testItem:
  202.             command = 't';
  203.             modifierMask = testMask;
  204.             break;
  205.         case commentItem:
  206.             command = 'z';
  207.             modifierMask = commentMask;
  208.             break;
  209.         case freshenItem:
  210.             command = 'f';
  211.             modifierMask = freshenMask;
  212.             break;
  213.         case updateItem:
  214.             command = 'u';
  215.             modifierMask = updateMask;
  216.             break;
  217.         case quitItem:
  218.             stop = true;
  219.             break;
  220.         default:
  221.             break;
  222.         }
  223.         break;
  224.  
  225.     case editMenu:
  226.         break;
  227.  
  228.     case modifierMenu:
  229.         switch (theitem) {
  230.         case excludeItem:
  231.             check = -1;
  232.             break;
  233.         case selectItem:
  234.             thedialog = GetNewDialog(selectDialog, nil, (WindowPtr)(-1));
  235.             SetPort(thedialog);
  236.             do
  237.                 ModalDialog(nil, &theitem);
  238.             while ((theitem != okItem) && (theitem != cancelItem));
  239.             if (theitem == okItem) {
  240.                 GetDItem(thedialog, editItem, &itemType, &itemHandle, &itemRect);
  241.                 GetIText(itemHandle, (StringPtr)&fileList);
  242.                 p2cstr((StringPtr)fileList);
  243.             }
  244.             DisposDialog(thedialog);
  245.             check = -1;
  246.             break;
  247.         case quietItem:
  248.             check = (modifiers ^= quietFlag) & quietFlag;
  249.             break;
  250.         case verboseItem:
  251.             check = (modifiers ^= verboseFlag) & verboseFlag;
  252.             break;
  253.         default:
  254.             break;
  255.         }
  256.         if (check == 0)
  257.             CheckItem(modifierHandle, theitem, false);
  258.         else if (check > 0)
  259.             CheckItem(modifierHandle, theitem, true);
  260.         break;
  261.  
  262.     case screenMenu:
  263.         switch (theitem) {
  264.         case pauseItem:
  265.             check = (modifiers ^= pauseFlag) & pauseFlag;
  266.             screenControl("p", check);
  267.             break;
  268.         case scrollItem:
  269.             check = (modifiers ^= scrollFlag) & scrollFlag;
  270.             screenControl("s", check);
  271.             break;
  272.         default:
  273.             break;
  274.         }
  275.         if (check == 0)
  276.             CheckItem(screenHandle, theitem, false);
  277.         else if (check > 0)
  278.             CheckItem(screenHandle, theitem, true);
  279.         break;
  280.  
  281.     case extractMenu:
  282.         switch (theitem) {
  283.         case screenItem:
  284.             check = (modifiers ^= screenFlag) & screenFlag;
  285.             break;
  286.         case junkItem:
  287.             check = (modifiers ^= junkFlag) & junkFlag;
  288.             break;
  289.         default:
  290.             break;
  291.         }
  292.         if (check == 0)
  293.             CheckItem(extractHandle, theitem, false);
  294.         else if (check > 0)
  295.             CheckItem(extractHandle, theitem, true);
  296.         break;
  297.  
  298.     case caseMenu:
  299.         switch (theitem) {
  300.         case insensitiveItem:
  301.             check = (modifiers ^= insensitiveFlag) & insensitiveFlag;
  302.             break;
  303.         case lowercaseItem:
  304.             check = (modifiers ^= lowercaseFlag) & lowercaseFlag;
  305.             break;
  306.         default:
  307.             break;
  308.         }
  309.         if (check == 0)
  310.             CheckItem(caseHandle, theitem, false);
  311.         else if (check > 0)
  312.             CheckItem(caseHandle, theitem, true);
  313.         break;
  314.  
  315.     case convertMenu:
  316.         switch (theitem) {
  317.         case autoItem:
  318.             CheckItem(convertHandle, autoItem, true);
  319.             CheckItem(convertHandle, binaryItem, false);
  320.             CheckItem(convertHandle, textItem, false);
  321.             modifiers &= (allFlags ^ textFlag);
  322.             modifiers |= autoFlag;
  323.             break;
  324.         case binaryItem:
  325.             CheckItem(convertHandle, autoItem, false);
  326.             CheckItem(convertHandle, binaryItem, true);
  327.             CheckItem(convertHandle, textItem, false);
  328.             modifiers &= (allFlags ^ (autoFlag | textFlag));
  329.             break;
  330.         case textItem:
  331.             CheckItem(convertHandle, autoItem, false);
  332.             CheckItem(convertHandle, binaryItem, false);
  333.             CheckItem(convertHandle, textItem, true);
  334.             modifiers &= (allFlags ^ autoFlag);
  335.             modifiers |= textFlag;
  336.             break;
  337.         default:
  338.             break;
  339.         }
  340.         break;
  341.  
  342.     case overwriteMenu:
  343.         switch (theitem) {
  344.         case alwaysItem:
  345.             CheckItem(overwriteHandle, alwaysItem, true);
  346.             CheckItem(overwriteHandle, neverItem, false);
  347.             CheckItem(overwriteHandle, promptItem, false);
  348.             modifiers &= (allFlags ^ neverFlag);
  349.             modifiers |= overwriteFlag;
  350.             break;
  351.         case neverItem:
  352.             CheckItem(overwriteHandle, alwaysItem, false);
  353.             CheckItem(overwriteHandle, neverItem, true);
  354.             CheckItem(overwriteHandle, promptItem, false);
  355.             modifiers &= (allFlags ^ overwriteFlag);
  356.             modifiers |= neverFlag;
  357.             break;
  358.         case promptItem:
  359.             CheckItem(overwriteHandle, alwaysItem, false);
  360.             CheckItem(overwriteHandle, neverItem, false);
  361.             CheckItem(overwriteHandle, promptItem, true);
  362.             modifiers &= (allFlags ^ (neverFlag | overwriteFlag));
  363.             break;
  364.         default:
  365.             break;
  366.         }
  367.         break;
  368.  
  369.     case infoMenu:
  370.         switch (theitem) {
  371.         case prtCommentItem:
  372.             check = (modifiers ^= prtCommentFlag) & prtCommentFlag;
  373.             break;
  374.         case prtHeaderItem:
  375.             check = (modifiers ^= prtHeaderFlag) & prtHeaderFlag;
  376.             break;
  377.         case prtTotalsItem:
  378.             check = (modifiers ^= prtTotalsFlag) & prtTotalsFlag;
  379.             break;
  380.         default:
  381.             break;
  382.         }
  383.         if (check == 0)
  384.             CheckItem(infoHandle, theitem, false);
  385.         else if (check > 0)
  386.             CheckItem(infoHandle, theitem, true);
  387.         break;
  388.  
  389.     case formatMenu:
  390.         switch (theitem) {
  391.         case filenameItem:
  392.             CheckItem(formatHandle, filenameItem, true);
  393.             CheckItem(formatHandle, longItem, false);
  394.             CheckItem(formatHandle, mediumItem, false);
  395.             CheckItem(formatHandle, shortItem, false);
  396.             modifiers &= (allFlags ^ (longFlag | mediumFlag | shortFlag));
  397.             modifiers |= filenameFlag;
  398.             break;
  399.         case longItem:
  400.             CheckItem(formatHandle, filenameItem, false);
  401.             CheckItem(formatHandle, longItem, true);
  402.             CheckItem(formatHandle, mediumItem, false);
  403.             CheckItem(formatHandle, shortItem, false);
  404.             modifiers &= (allFlags ^ (filenameFlag | mediumFlag | shortFlag));
  405.             modifiers |= longFlag;
  406.             break;
  407.         case mediumItem:
  408.             CheckItem(formatHandle, filenameItem, false);
  409.             CheckItem(formatHandle, longItem, false);
  410.             CheckItem(formatHandle, mediumItem, true);
  411.             CheckItem(formatHandle, shortItem, false);
  412.             modifiers &= (allFlags ^ (filenameFlag | longFlag | shortFlag));
  413.             modifiers |= mediumFlag;
  414.             break;
  415.         case shortItem:
  416.             CheckItem(formatHandle, filenameItem, false);
  417.             CheckItem(formatHandle, longItem, false);
  418.             CheckItem(formatHandle, mediumItem, false);
  419.             CheckItem(formatHandle, shortItem, true);
  420.             modifiers &= (allFlags ^ (filenameFlag | longFlag | mediumFlag));
  421.             modifiers |= shortFlag;
  422.             break;
  423.         default:
  424.             break;
  425.         }
  426.         break;
  427.  
  428.     default:
  429.         break;
  430.  
  431.     }
  432.  
  433.     HiliteMenu(0);
  434.     return;
  435. }
  436.  
  437. static void dokey(myevent) EventRecord *myevent;
  438. {
  439.     char code;
  440.  
  441.     code = (char)(myevent->message & charCodeMask);
  442.  
  443.     if (myevent->modifiers & cmdKey) {
  444.         if (myevent->what != autoKey) {
  445.             domenu(MenuKey(code));
  446.         }
  447.     }
  448.  
  449.     return;
  450. }
  451.  
  452. static void domousedown(myevent) EventRecord *myevent;
  453. {
  454.     WindowPtr whichwindow;
  455.     long code;
  456.  
  457.     code = FindWindow(myevent->where, &whichwindow);
  458.  
  459.     switch (code) {
  460.  
  461.     case inSysWindow:
  462.         SystemClick(myevent, whichwindow);
  463.         break;
  464.  
  465.     case inMenuBar:
  466.         domenu(MenuSelect(myevent->where));
  467.         break;
  468.  
  469.     }
  470.  
  471.     return;
  472. }
  473.  
  474. int main(argc, argv) int argc; char *argv[];
  475. {
  476.     struct Globals saveGlobals;
  477.     Boolean haveEvent, useWNE;
  478.     short markChar;
  479.     FILE *fp;
  480.  
  481.     FlushEvents(everyEvent, 0);
  482.     InitGraf(&qd.thePort);
  483.     InitFonts();
  484.     InitWindows();
  485.     InitMenus();
  486.     TEInit();
  487.     InitDialogs(nil);
  488.     InitCursor();
  489.  
  490.     CONSTRUCTGLOBALS();
  491.  
  492.     sprintf(UnzipVersion, "%d.%d%d%s of %s", UZ_MAJORVER, UZ_MINORVER,
  493.         PATCHLEVEL, BETALEVEL, VERSION_DATE);
  494.     sprintf(ZipinfoVersion, "%d.%d%d%s of %s", ZI_MAJORVER, ZI_MINORVER,
  495.         PATCHLEVEL, BETALEVEL, VERSION_DATE);
  496.  
  497.     c2pstr(UnzipVersion);
  498.     c2pstr(ZipinfoVersion);
  499.  
  500.     SysEnvirons(1, &sysRec);
  501.     useWNE = TrapAvailable(sysRec.machineType, _WaitNextEvent, ToolTrap);
  502.  
  503.     SetMenuBar(menubar = GetNewMBar(unzipMenuBar));
  504.     DisposeHandle(menubar);
  505.     InsertMenu(GetMenu(screenMenu), -1);
  506.     InsertMenu(GetMenu(extractMenu), -1);
  507.     InsertMenu(GetMenu(caseMenu), -1);
  508.     InsertMenu(GetMenu(convertMenu), -1);
  509.     InsertMenu(GetMenu(overwriteMenu), -1);
  510.     InsertMenu(GetMenu(infoMenu), -1);
  511.     InsertMenu(GetMenu(formatMenu), -1);
  512.     AddResMenu(appleHandle = GetMHandle(appleMenu), 'DRVR');
  513.     modifierHandle = GetMHandle(modifierMenu);
  514.     screenHandle = GetMHandle(screenMenu);
  515.     extractHandle = GetMHandle(extractMenu);
  516.     caseHandle = GetMHandle(caseMenu);
  517.     convertHandle = GetMHandle(convertMenu);
  518.     overwriteHandle = GetMHandle(overwriteMenu);
  519.     infoHandle = GetMHandle(infoMenu);
  520.     formatHandle = GetMHandle(formatMenu);
  521.     DrawMenuBar();
  522.  
  523.     screenOpen("Unzip");
  524.  
  525.     modifiers = 0;
  526.  
  527.     GetItemMark(modifierHandle, quietItem, &markChar);
  528.     if (markChar) modifiers ^= quietFlag;
  529.     GetItemMark(modifierHandle, verboseItem, &markChar);
  530.     if (markChar) modifiers ^= verboseFlag;
  531.  
  532.     GetItemMark(screenHandle, pauseItem, &markChar);
  533.     if (markChar) modifiers ^= pauseFlag;
  534.     screenControl("p", markChar);
  535.     GetItemMark(screenHandle, scrollItem, &markChar);
  536.     if (markChar) modifiers ^= scrollFlag;
  537.     screenControl("s", markChar);
  538.  
  539.     GetItemMark(extractHandle, screenItem, &markChar);
  540.     if (markChar) modifiers ^= screenFlag;
  541.     GetItemMark(extractHandle, junkItem, &markChar);
  542.     if (markChar) modifiers ^= junkFlag;
  543.  
  544.     GetItemMark(caseHandle, insensitiveItem, &markChar);
  545.     if (markChar) modifiers ^= insensitiveFlag;
  546.     GetItemMark(caseHandle, lowercaseItem, &markChar);
  547.     if (markChar) modifiers ^= lowercaseFlag;
  548.  
  549.     GetItemMark(convertHandle, autoItem, &markChar);
  550.     if (markChar) modifiers ^= autoFlag;
  551.     GetItemMark(convertHandle, textItem, &markChar);
  552.     if (markChar) modifiers ^= textFlag;
  553.  
  554.     if ((modifiers & (autoFlag | textFlag)) == (autoFlag | textFlag)) {
  555.         CheckItem(convertHandle, textItem, false);
  556.         modifiers &= (allFlags ^ textFlag);
  557.     } else if (modifiers & (autoFlag | textFlag))
  558.         CheckItem(convertHandle, binaryItem, false);
  559.     else
  560.         CheckItem(convertHandle, binaryItem, true);
  561.  
  562.     GetItemMark(overwriteHandle, alwaysItem, &markChar);
  563.     if (markChar) modifiers ^= overwriteFlag;
  564.     GetItemMark(overwriteHandle, neverItem, &markChar);
  565.     if (markChar) modifiers ^= neverFlag;
  566.  
  567.     if ((modifiers & (neverFlag | overwriteFlag)) == (neverFlag | overwriteFlag)) {
  568.         CheckItem(overwriteHandle, alwaysItem, false);
  569.         CheckItem(overwriteHandle, neverItem, false);
  570.         CheckItem(overwriteHandle, promptItem, true);
  571.         modifiers &= (allFlags ^ (neverFlag | overwriteFlag));
  572.     } else if (modifiers & (neverFlag | overwriteFlag))
  573.         CheckItem(overwriteHandle, promptItem, false);
  574.     else
  575.         CheckItem(overwriteHandle, promptItem, true);
  576.  
  577.     GetItemMark(infoHandle, prtCommentItem, &markChar);
  578.     if (markChar) modifiers ^= prtCommentFlag;
  579.     GetItemMark(infoHandle, prtHeaderItem, &markChar);
  580.     if (markChar) modifiers ^= prtHeaderFlag;
  581.     GetItemMark(infoHandle, prtTotalsItem, &markChar);
  582.     if (markChar) modifiers ^= prtTotalsFlag;
  583.  
  584.     GetItemMark(formatHandle, filenameItem, &markChar);
  585.     if (markChar) modifiers ^= filenameFlag;
  586.     GetItemMark(formatHandle, longItem, &markChar);
  587.     if (markChar) modifiers ^= longFlag;
  588.     GetItemMark(formatHandle, mediumItem, &markChar);
  589.     if (markChar) modifiers ^= mediumFlag;
  590.     GetItemMark(formatHandle, shortItem, &markChar);
  591.     if (markChar) modifiers ^= shortFlag;
  592.  
  593.     if (modifiers & longFlag) {
  594.         CheckItem(formatHandle, filenameItem, false);
  595.         CheckItem(formatHandle, mediumItem, false);
  596.         CheckItem(formatHandle, shortItem, false);
  597.         modifiers &= (allFlags ^ (filenameFlag | mediumFlag | shortFlag));
  598.     } else if (modifiers & mediumFlag) {
  599.         CheckItem(formatHandle, filenameItem, false);
  600.         CheckItem(formatHandle, shortItem, false);
  601.         modifiers &= (allFlags ^ (filenameFlag | shortFlag));
  602.     } else if (modifiers & shortFlag) {
  603.         CheckItem(formatHandle, filenameItem, false);
  604.         modifiers &= (allFlags ^ filenameFlag);
  605.     }
  606.  
  607.     command = ' ';
  608.  
  609.     stop = false;
  610.     while (!stop) {
  611.         SetCursor(&qd.arrow);
  612.  
  613.         if (useWNE) {
  614.             haveEvent = WaitNextEvent(everyEvent, &myevent, LONG_MAX, NULL);
  615.         } else {
  616.             SystemTask();
  617.             haveEvent = GetNextEvent(everyEvent, &myevent);
  618.         }
  619.  
  620.         if (haveEvent) {
  621.             switch (myevent.what) {
  622.  
  623.             case activateEvt:
  624.                 break;
  625.  
  626.             case keyDown:
  627.             case autoKey:
  628.                 dokey(&myevent);
  629.                 break;
  630.  
  631.             case mouseDown:
  632.                 domousedown(&myevent);
  633.                 break;
  634.  
  635.             case updateEvt:
  636.                 screenUpdate((WindowPtr)myevent.message);
  637.                 break;
  638.  
  639.             case mouseUp:
  640.             case keyUp:
  641.                 break;
  642.  
  643.             default:
  644.                 break;
  645.  
  646.             }
  647.         }
  648.  
  649.         if (command != ' ') {
  650.             char *s, **v, modifierString[32];
  651.             SFReply fileRep;
  652.             Point p;
  653.             int m, n;
  654.  
  655.             SetPt(&p, 40, 40);
  656.  
  657.             SFGetFile(p, "\pSpecify ZIP file:", 0L, -1, nil, 0L, &fileRep);
  658.             if (fileRep.good) {
  659.                 MacFSTest(fileRep.vRefNum);
  660.                 ResolveMacVol(fileRep.vRefNum, &G.gnVRefNum, &G.glDirID, NULL);
  661.  
  662.                 p2cstr((StringPtr)fileRep.fName);
  663.  
  664.                 modifierMask &= modifiers;
  665.  
  666.                 s = modifierString;
  667.  
  668.                 *s++ = '-';
  669.                 if ((command != 'x') && (command != 'Z')) *s++ = command;
  670.  
  671.                 if (modifierMask) {
  672.                     if (modifierMask & (autoFlag | textFlag)) *s++ = 'a';
  673.                     if (modifierMask & textFlag) *s++ = 'a';
  674.                     if (modifierMask & insensitiveFlag) *s++ = 'C';
  675.                     if (!G.HFSFlag || (modifierMask & junkFlag)) *s++ = 'j';
  676.                     if (modifierMask & lowercaseFlag) *s++ = 'L';
  677.                     if (modifierMask & neverFlag) *s++ = 'n';
  678.                     if (modifierMask & overwriteFlag) *s++ = 'o';
  679.                     if (modifierMask & quietFlag) *s++ = 'q';
  680.                     if (modifierMask & verboseFlag) *s++ = 'v';
  681.  
  682.                     if (modifierMask & prtCommentFlag) *s++ = 'z';
  683.                     if (modifierMask & prtHeaderFlag) *s++ = 'h';
  684.                     if (modifierMask & prtTotalsFlag) *s++ = 't';
  685.                     if (modifierMask & filenameFlag) *s++ = '2';
  686.                     if (modifierMask & longFlag) *s++ = 'l';
  687.                     if (modifierMask & mediumFlag) *s++ = 'm';
  688.                     if (modifierMask & shortFlag) *s++ = 's';
  689.                 }
  690.  
  691.                 if (*(s - 1) == '-') s -= 1;
  692.  
  693.                 *s = '\0';
  694.  
  695.                 v = (char **)malloc(sizeof(char *));
  696.                 *v = "unzip";
  697.                 argc = 1;
  698.  
  699.                 envargs(&argc, &v, NULL, NULL);
  700.  
  701.                 argv = (char **)malloc((argc + 3) * sizeof(char *));
  702.  
  703.                 argv[m = 0] = (command == 'Z') ? "zipinfo" : "unzip";
  704.                 if (*modifierString) argv[++m] = modifierString;
  705.                 argv[++m] = (char *)fileRep.fName;
  706.                 for (n = 1; n < argc; n++) argv[n + m] = v[n];
  707.                 argv[argc += m] = NULL;
  708.  
  709.                 free(v);
  710.  
  711.                 for (n = 0; argv[n] != NULL; n++) printf("%s ", argv[n]);
  712.                 printf("...\n\n");
  713.  
  714.                 memcpy(&saveGlobals, &G, sizeof(struct Globals));
  715.  
  716.                 unzip(__G__ argc, argv);
  717.                 
  718.                 memcpy(&G, &saveGlobals, sizeof(struct Globals));
  719.  
  720.                 printf("\nDone\n");
  721.             }
  722.  
  723.             fileList[0] = '\0';
  724.             command = ' ';
  725.         }
  726.     }
  727.  
  728.     screenClose();
  729.  
  730.     DESTROYGLOBALS()
  731.  
  732.     ExitToShell();
  733. }
  734.