home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 392.lha / CompDisk / CompDisk.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-07-03  |  49.1 KB  |  1,958 lines
  1.     /* The usual Arp CLI interface data. */
  2.  
  3. char *CLI_Template    = "FILE/A,DRIVE/A,NOCLEAR/S";
  4. char *CLI_Help        = "\nUsage: CompDisk [FILE <FileName>] [DRIVE <DF0:, DF1:, RAD:, etc.>] [NOCLEAR]\n";
  5.  
  6.     /* Argument vector offsets. */
  7.  
  8. #define ARG_FILE    1
  9. #define ARG_DRIVE    2
  10. #define ARG_NOCLEAR    3
  11.  
  12.     /* Some constants useful when playing with the disk. */
  13.  
  14. #define NUMBLOCKS    (80 * 2 * NUMSECS)
  15. #define ROOTBLOCK    (NUMBLOCKS / 2)
  16. #define LWORDS        (NUMBLOCKS / 32)
  17. #define TRACKSIZE    (TD_SECTOR * NUMSECS * 2)
  18. #define EXTRA        (2 * 16)
  19. #define EXTRASIZE    (2 * (TD_SECTOR * NUMSECS + 16))
  20.  
  21.     /* Punches a string into the window. */
  22.  
  23. #define Punch(s)    Text(RPort,s,strlen(s))
  24.  
  25.     /* Function prototypes. */
  26.  
  27. VOID            Announce(VOID);
  28. LONG __regargs        DoBlockCrc(UBYTE *,LONG);
  29. LONG            Inhibit(char *,LONG);
  30. UBYTE *            B2C(UBYTE *,BSTR);
  31. LONG            DriverAction(LONG,LONG *,LONG);
  32. VOID __regargs        ClearTrack(UBYTE *,LONG);
  33. ULONG __regargs        CheckSum(ULONG *);
  34. LONG            GetBitmap(struct CompInfo *);
  35. LONG            MakeID(char *);
  36. LONG            GetFileSize(char *);
  37. LONG            ReadDump(char *,char *);
  38. LONG            FindDevice(char *);
  39. VOID            EraseGadget(struct RastPort *,struct Gadget *,LONG);
  40. LONG            GetChangeCount(LONG);
  41. VOID __regargs        ClearMem(char *,LONG);
  42.  
  43. LONG            CXBRK(VOID);
  44. VOID __stdargs        main(LONG,char **);
  45.  
  46.     /* These are imported from CompSub.c */
  47.  
  48. VOID            compexit(VOID);
  49. LONG            compinit(VOID);
  50. LONG __regargs        compfiles(unsigned char *,LONG,unsigned char *,LONG);
  51.  
  52.     /* Global data. */
  53.  
  54. struct IOExtTD        *DiskRequest;
  55. struct MsgPort        *DiskPort;
  56. struct Library        *ReqBase;
  57. struct Library        *IconBase;
  58. extern struct ExecBase    *SysBase;
  59. struct TextFont        *TextFont;
  60. LONG             ClearBlocks = TRUE;
  61. LONG            *Sector,*ChipSector;
  62. BYTE             BlockTab[NUMBLOCKS + 2];
  63. UBYTE             Legal[5];
  64. LONG             ChangeCount[4];
  65. struct IntuiMessage    *Massage;
  66. struct Gadget        *Gadget;
  67. LONG             Class,Code,DriveWanted = -1;
  68.  
  69.     /* Program version & dump file ID. */
  70.  
  71. #define PRGVERSION    6
  72. #define PROGRAMID    "COMP"
  73.  
  74.     /* This is the format of the standard dump file header. */
  75.  
  76. struct CompInfo
  77. {
  78.     LONG    ci_ProgramID;    /* Dump file ID. */
  79.     LONG    ci_Version;    /* Version of program file was created with. */
  80.     LONG    ci_Compression;    /* Compression mode. */
  81.     ULONG    ci_ExtFlags;    /* Various extension flags. */
  82. };
  83.  
  84.     /* This gets set in CompInfo . ci_ExtFlags if disk has a root-block. */
  85.  
  86. #define CI_HASROOT    0x00000001
  87.  
  88.     /* This follows a bunch of gadget definitions. */
  89.  
  90. struct TextAttr TxtAttr = {(UBYTE *)"topaz.font",8,0,65};
  91.  
  92. struct IntuiText BoxIntTxt[6] =
  93. {
  94.     {1,0,JAM1,24,  3,&TxtAttr,(UBYTE *)"RAD: ",        (struct IntuiText *)NULL},
  95.     {1,0,JAM1,24,  3,&TxtAttr,(UBYTE *)"DF3: ",        (struct IntuiText *)NULL},
  96.     {1,0,JAM1,24,  3,&TxtAttr,(UBYTE *)"DF2: ",        (struct IntuiText *)NULL},
  97.     {1,0,JAM1,24,  3,&TxtAttr,(UBYTE *)"DF1: ",        (struct IntuiText *)NULL},
  98.     {1,0,JAM1,24,  3,&TxtAttr,(UBYTE *)"DF0: ",        (struct IntuiText *)NULL},
  99.     {1,0,JAM2,36,-11,&TxtAttr,(UBYTE *)"  Pathname ",    (struct IntuiText *)NULL}
  100. };
  101.  
  102. UBYTE StrInfStr[160];
  103. UBYTE UndoStrInfStr[160];
  104.  
  105. struct StringInfo BoxStrInf = {&StrInfStr[0],&UndoStrInfStr[0],0,160,23,0,0,0,0,NULL,NULL,NULL};
  106.  
  107. SHORT BoxBrdDat[] =
  108. {
  109.     -1,-1,88,-1,88,14,-1,14,-1,0,
  110.     -2,-1,89,-1,89,14,-2,14,-2,-1,
  111.     -1,-1,88,-1,88,14,-1,14,-1,0,
  112.     -2,-1,89,-1,89,14,-2,14,-2,-1,
  113.     -1,-1,88,-1,88,14,-1,14,-1,0,
  114.     -2,-1,89,-1,89,14,-2,14,-2,-1,
  115.     -1,-1,88,-1,88,14,-1,14,-1,0,
  116.     -2,-1,89,-1,89,14,-2,14,-2,-1,
  117.     -1,-1,88,-1,88,14,-1,14,-1,0,
  118.     -2,-1,89,-1,89,14,-2,14,-2,-1,
  119.     -1,-1,88,-1,95,-1,184,-1,184,8,95,8,88,8,-1,8,-1,-1,
  120.     -2,-1,185,-1,185,8,-2,8,-2,-1,
  121. };
  122.  
  123. struct Border BoxBrd[] =
  124. {
  125.     {0,0,1,0,0,5,&BoxBrdDat[  0],&BoxBrd[1]},
  126.     {0,0,1,0,0,5,&BoxBrdDat[ 10],NULL},
  127.     {0,0,1,0,0,5,&BoxBrdDat[ 20],&BoxBrd[3]},
  128.     {0,0,1,0,0,5,&BoxBrdDat[ 30],NULL},
  129.     {0,0,1,0,0,5,&BoxBrdDat[ 40],&BoxBrd[5]},
  130.     {0,0,1,0,0,5,&BoxBrdDat[ 50],NULL},
  131.     {0,0,1,0,0,5,&BoxBrdDat[ 60],&BoxBrd[7]},
  132.     {0,0,1,0,0,5,&BoxBrdDat[ 70],NULL},
  133.     {0,0,1,0,0,5,&BoxBrdDat[ 80],&BoxBrd[9]},
  134.     {0,0,1,0,0,5,&BoxBrdDat[ 90],NULL},
  135.     {0,0,1,0,0,9,&BoxBrdDat[100],&BoxBrd[11]},
  136.     {0,0,1,0,0,5,&BoxBrdDat[118],NULL},
  137. };
  138.  
  139. struct Gadget BoxGad[6] =
  140. {
  141.     {&BoxGad[1],  6,71, 88,14,0,  3,1,(APTR)&BoxBrd[ 0],NULL,&BoxIntTxt[0],NULL,NULL,        0,NULL},
  142.     {&BoxGad[2],102,53, 88,14,0,  3,1,(APTR)&BoxBrd[ 2],NULL,&BoxIntTxt[1],NULL,NULL,        1,NULL},
  143.     {&BoxGad[3],  6,53, 88,14,0,  3,1,(APTR)&BoxBrd[ 4],NULL,&BoxIntTxt[2],NULL,NULL,        2,NULL},
  144.     {&BoxGad[4],102,35, 88,14,0,  3,1,(APTR)&BoxBrd[ 6],NULL,&BoxIntTxt[3],NULL,NULL,        3,NULL},
  145.     {&BoxGad[5],  6,35, 88,14,0,  3,1,(APTR)&BoxBrd[ 8],NULL,&BoxIntTxt[4],NULL,NULL,        4,NULL},
  146.     {NULL,        6,23,184, 8,0,515,4,(APTR)&BoxBrd[10],NULL,&BoxIntTxt[5],NULL,(APTR)&BoxStrInf,    5,NULL}
  147. };
  148.  
  149.     /* The window title (gets filled in later). */
  150.  
  151. UBYTE WindowName[20];
  152.  
  153.     /* The new window definition. */
  154.  
  155. struct NewWindow NewWindow =
  156. {
  157.     0,11,
  158.     196,88,
  159.     -1,-1,
  160.     CLOSEWINDOW | DISKINSERTED | GADGETUP,
  161.     ACTIVATE | RMBTRAP | WINDOWDRAG | WINDOWCLOSE | WINDOWDEPTH,
  162.     (struct Gadget *)&BoxGad[0],
  163.     (struct Image *)NULL,
  164.     WindowName,
  165.     (struct Screen *)NULL,
  166.     (struct BitMap *)NULL,
  167.     0,0,
  168.     0,0,
  169.     WBENCHSCREEN
  170. };
  171.  
  172.     /* Some window interface data. */
  173.  
  174. struct Window    *Window;
  175. struct RastPort    *RPort;
  176.  
  177.     /* All five supported drives. */
  178.  
  179. char *Drives[5] =
  180. {
  181.     "RAD:",
  182.     "DF3:",
  183.     "DF2:",
  184.     "DF1:",
  185.     "DF0:"
  186. };
  187.  
  188.     /* Icon definition, image 1. */
  189.  
  190. USHORT Image1Data[126] =
  191. {
  192.     /* Plane 0 */
  193.  
  194.     0x001F,0xFFFF,0x0000,0x001F,0xFF07,0x0000,0x001F,0xFF07,
  195.     0x0000,0x001F,0xFF07,0x0000,0x001F,0xFF07,0x0000,0x001F,
  196.     0xFFFF,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
  197.     0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x00FF,0xF7F7,
  198.     0xE000,0x00FF,0xEFFB,0xE000,0x00FF,0xDFFD,0xE000,0x00FF,
  199.     0xAFFE,0xE000,0x00FF,0x7FFF,0xE000,0x00FE,0xFFFF,0xE000,
  200.     0x00FD,0xFFFF,0xE000,0x00FB,0xFFFF,0xE000,0x00F7,0xFFFF,
  201.     0xE000,0x00EF,0xFFFF,0xE000,0x0000,0x0000,0x0000,
  202.  
  203.     /* Plane 1 */
  204.  
  205.     0x7FE0,0x0000,0xFF80,0xFFE0,0x00F8,0xFFC0,0xFFE0,0x00F8,
  206.     0xFFE0,0xFFE0,0x00F8,0xFFE0,0xFFE0,0x00F8,0xFFE0,0xFFE0,
  207.     0x0000,0xFFE0,0xFFFF,0xFFFF,0xFFE0,0xFFFF,0xFFFF,0xFFE0,
  208.     0xFFFF,0xFFFF,0xFFE0,0xFFFF,0xFFFF,0xFFE0,0xFF3E,0xFCF8,
  209.     0x1FE0,0xFF7D,0xFE7C,0x1FE0,0xFFFB,0xFF3E,0x1FE0,0xFFF7,
  210.     0xDF9F,0x1FE0,0xFFEF,0x8000,0x1FE0,0xFFDF,0x0000,0x1FE0,
  211.     0xE3BE,0x0000,0x1FE0,0xE37C,0x0000,0x1FE0,0xFFF8,0x0000,
  212.     0x1FE0,0x7FF0,0x0000,0x1FC0,0x0000,0x0000,0x0000
  213. };
  214.  
  215. struct Image Image1 =
  216. {
  217.     0,0,
  218.     43,21,2,
  219.     (USHORT *)&Image1Data[0],
  220.     0x03,0x00,
  221.     (struct Image *)NULL
  222. };
  223.  
  224.     /* Icon definition, image 2. */
  225.  
  226. USHORT Image2Data[126] =
  227. {
  228.     /* Plane 0 */
  229.  
  230.     0x07FF,0xFFC0,0x0000,0x07FF,0xD5C0,0x0000,0x07FF,0xEBC0,
  231.     0x0000,0x07FF,0xD5C0,0x0000,0x07FF,0xEBC0,0x0000,0x07FF,
  232.     0xFFC0,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
  233.     0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x00FF,0xF7F7,
  234.     0xE000,0x00FF,0xEFFB,0xE000,0x00FF,0xDFFD,0xE000,0x00FF,
  235.     0xAFFE,0xE000,0x00FF,0x7FFF,0xE000,0x00FE,0xFFFF,0xE000,
  236.     0x00FD,0xFFFF,0xE000,0x00FB,0xFFFF,0xE000,0x00F7,0xFFFF,
  237.     0xE000,0x00EF,0xFFFF,0xE000,0x0000,0x0000,0x0000,
  238.  
  239.     /* Plane 1 */
  240.  
  241.     0x7800,0x003F,0xFF80,0xF800,0x3E3F,0xFFC0,0xF800,0x3E3F,
  242.     0xFFE0,0xF800,0x3E3F,0xFFE0,0xF800,0x3E3F,0xFFE0,0xF800,
  243.     0x003F,0xFFE0,0xFFFF,0xFFFF,0xFFE0,0xFFFF,0xFFFF,0xFFE0,
  244.     0xFFFF,0xFFFF,0xFFE0,0xFFFF,0xFFFF,0xFFE0,0xFF3E,0xFCF8,
  245.     0x1FE0,0xFF7D,0xFE7C,0x1FE0,0xFFFB,0xFF3E,0x1FE0,0xFFF7,
  246.     0xDF9F,0x1FE0,0xFFEF,0x8000,0x1FE0,0xFFDF,0x0000,0x1FE0,
  247.     0xE3BE,0x0000,0x1FE0,0xE37C,0x0000,0x1FE0,0xFFF8,0x0000,
  248.     0x1FE0,0x7FF0,0x0000,0x1FC0,0x0000,0x0000,0x0000
  249. };
  250.  
  251. struct Image Image2 =
  252. {
  253.     0,0,
  254.     43,21,2,
  255.     (USHORT *)&Image2Data[0],
  256.     0x03,0x00,
  257.     (struct Image *)NULL
  258. };
  259.  
  260.     /* The tooltypes entries for this icon. */
  261.  
  262. char *ToolTypes[] =
  263. {
  264.     "FILETYPE=COMPDISK",
  265.     NULL
  266. };
  267.  
  268.     /* The icon data itself. */
  269.  
  270. struct DiskObject ProjectIcon =
  271. {
  272.     WB_DISKMAGIC,
  273.     WB_DISKVERSION,
  274.  
  275.     (struct Gadget *)NULL,
  276.     0,0,
  277.     43,21,
  278.     GADGIMAGE | GADGHIMAGE,
  279.     RELVERIFY | GADGIMMEDIATE,
  280.     BOOLGADGET,
  281.     (APTR)&Image1,
  282.     (APTR)&Image2,
  283.     (struct IntuiText *)NULL,
  284.     NULL,
  285.     (APTR)NULL,
  286.     NULL,
  287.     (APTR)NULL,
  288.  
  289.     WBPROJECT,
  290.     "SYS:System/DecompDisk",
  291.     ToolTypes,
  292.     NO_ICON_POSITION,
  293.     NO_ICON_POSITION,
  294.     (struct DrawerData *)NULL,
  295.     (char *)NULL,
  296.     10000
  297. };
  298.  
  299.     /* This macro saves the icon to a named file. */
  300.  
  301. #define SaveProjectIcon(Destination) PutDiskObject(Destination,&ProjectIcon)
  302.  
  303.     /* This macro sets the "busy" pointer for a window. */
  304.  
  305. #define SetWait(Window) SetPointer(Window,ElecArtsWaitPointer,22,16,0,0)
  306.  
  307.     /* The mouse pointer definition. */
  308.  
  309. USHORT __chip ElecArtsWaitPointer[(22 * 2) + 4] =
  310. {
  311.     0x0000,0x0000,
  312.  
  313.     0x6700,0xC000,
  314.     0xCFA0,0xC700,
  315.     0xBFF0,0x0FA0,
  316.     0x70F8,0x3FF0,
  317.     0x7DFC,0x3FF8,
  318.     0xFBFC,0x7FF8,
  319.     0x70FC,0x3FF8,
  320.     0x7FFE,0x3FFC,
  321.     0x7F0E,0x3FFC,
  322.     0x3FDF,0x1FFE,
  323.     0x7FBE,0x3FFC,
  324.     0x3F0E,0x1FFC,
  325.     0x1FFC,0x07F8,
  326.     0x07F8,0x01E0,
  327.     0x01E0,0x0080,
  328.     0x07C0,0x0340,
  329.     0x0FE0,0x07C0,
  330.     0x0740,0x0200,
  331.     0x0000,0x0000,
  332.     0x0070,0x0020,
  333.     0x0078,0x0038,
  334.     0x0038,0x0010,
  335.  
  336.     0x0000,0x0000
  337. };
  338.  
  339.     /* Announce():
  340.      *
  341.      *    Beeps thrice (Shakespeare is dead) to indicate special
  342.      *    program conditions.
  343.      */
  344.  
  345. VOID
  346. Announce()
  347. {
  348.     static UBYTE AnyChannel[4] = {1,2,4,8};
  349.  
  350.     static ULONG __chip SoundData[1086] =
  351.     {
  352.         0xFAF5F4D0,0xCF1720E4,0xEF1F1F3F,0x6410EF4F,0x7008F6F0,0xBCEF28C0,
  353.         0x80BF00C8,0xEFE09FFF,0x7F60E73F,0x78657F60,0xA8DF7B00,0x809B8083,
  354.         0xFF008083,0x3F400F3E,0x00FF7F7F,0x20FF7D50,0x2F408080,0xDF208080,
  355.         0x8F87DF5E,0xE0803F7F,0x606B7010,0x7F7F6080,0xEF20D0DF,0xA0808137,
  356.         0xD0809FF8,0x0F7F7FD0,0xFF7F7F40,0x4800DB77,0x608080BF,0xC08FB280,
  357.         0x801F7FC0,0xBF5F677F,0x7F60BF7F,0x7F20CBD0,0x80AF3680,0x808300C8,
  358.         0xCFC08FFF,0x7F78EB37,0x7F7F7F7E,0xE0FF7F60,0xC0A7A097,0xF7E08080,
  359.         0xBFE8B0BF,0xA4BF7F7F,0x20FF7F7F,0x7F7F40D7,0x6F7F1097,0xB3A0BFF8,
  360.         0x808081FF,0xC0A7B59F,0xFF7F70D8,0x3F7F7F7F,0x7800FF7F,0x70C09FC0,
  361.         0xB7E7C080,0x80DF0090,0x9FB0CF6F,0x7F00DF7F,0x7F7F7828,0x0F6F7F20,
  362.         0xA0AFCFE2,0xD0808083,0xF7D0949B,0xBF2F7F40,0xF02F7F7F,0x7F50123F,
  363.         0x7F60C89F,0xCFE5E0A0,0x8080CFF0,0xA085B7FF,0x5F7000FF,0x777F7F60,
  364.         0x282F7F7F,0x1097BFEB,0xE4C08080,0x8FFBC080,0x97DF2F6C,0x30E9377F,
  365.         0x7F70402F,0x5F7F50C0,0xAFDFF8D0,0x888080D7,0xE0A081BF,0x0F4F4000,
  366.         0xFF7F7F7F,0x48304F7F,0x7800A9CF,0xFFE8A880,0x80AFEEC0,0x809FEF37,
  367.         0x4818F73F,0x7F7F6032,0x3F6F7F40,0xC0BBFB00,0xC0808087,0xDFD88881,
  368.         0xBF1F3F28,0xF40F7F7F,0x78403B5F,0x7F7000AF,0xDF08E0A0,0x8080BFDA,
  369.         0xA8809FF7,0x2F2800FF,0x3F7F7F50,0x304F7F78,0x30D0CFFF,0x04C08080,
  370.         0x9FD7C080,0x87CF1F2E,0x08F71F7F,0x7F68303F,0x777F6000,0xCBEF14E0,
  371.         0x908083BF,0xD0A0809F,0xFF2B14F4,0xFF4F7F7E,0x4033677F,0x7420D0DF,
  372.         0x1300C080,0x81B7D3B0,0x808FD71B,0x2000F72F,0x7F7F602D,0x4F7F7E48,
  373.         0xF0DFFF14,0xE090809F,0xCFC89080,0xAFFF2000,0xEE0F577F,0x70343B6F,
  374.         0x7F6810E1,0xF71B00B0,0x808BBFD0,0xA8808FDF,0x1908EAF7,0x2F7F7E48,
  375.         0x2D577F7C,0x40F0EF17,0x18E09083,0xAFD1C084,0x80BFFF10,0xF2EB0F5F,
  376.         0x7E60303F,0x777F6010,0xF1072100,0xB0889FCF,0xC8A0809F,0xDF0F00E1,
  377.         0xFB377768,0x402F5F7F,0x7428F8FF,0x1F14D094,0x93BFD2B0,0x8487BFFF,
  378.         0x04E2E71B,0x5F74502B,0x477F7F48,0x08FD1724,0x00B08FAF,0xD5C49080,
  379.         0x9FEF08EC,0xDEFF3F6A,0x5832375F,0x7F682401,0x0F2710D0,0xA0A7CBD0,
  380.         0xA8818FCF,0xFDF4D8E7,0x1F5B6040,0x2D4F7F7C,0x40100B27,0x24F0B09F,
  381.         0xBFD6C088,0x83AFEBF8,0xE0D7FF3F,0x61482C3F,0x6F7F6020,0x0B1F3010,
  382.         0xD0A2B7D7,0xCCA08097,0xCFF7E4CE,0xE71F5B54,0x322F5F7F,0x74401017,
  383.         0x2F20F0B4,0xADCFD8B8,0x8887B7EB,0xECD1D7FF,0x3F544029,0x3F777F60,
  384.         0x20152D34,0x08C8AEBF,0xDBC89881,0x9FD7EED8,0xCBEF2B4F,0x42282F5F,
  385.         0x7F703416,0x273C20E8,0xB5BBD7D8,0xA8828FBF,0xE9E0C6CF,0x0F3F4C30,
  386.         0x27477B78,0x50241F39,0x3000D0BB,0xCFDAC090,0x87A7D7E0,0xCCCBEF2F,
  387.         0x4638263B,0x677E6030,0x21333C20,0xE0C0C7DD,0xD0A88597,0xBFDFD0C2,
  388.         0xD7173F3C,0x262D4F7B,0x7440242F,0x3F3000CC,0xC7DBDCC0,0x8C8FAFD7,
  389.         0xD4C0C7FF,0x2F3C2823,0x3F6F7A58,0x302A3F40,0x18E0C7D7,0xDFC8A08D,
  390.         0x9FC7D4C4,0xBFDF1733,0x2C202F5B,0x7668402E,0x3B463000,0xD4D7E3D8,
  391.         0xB49097B7,0xD1C6B9CB,0xFF272C20,0x23476F70,0x5034394A,0x4010E0D5,
  392.         0xE3E2C4A0,0x8FA7C7CA,0xB8BBDF0F,0x2B201B37,0x5F756040,0x37475028,
  393.         0xF4D9DFE6,0xD0A8909F,0xBDC8BCB5,0xCFFF1F22,0x1B274F6F,0x68503A43,
  394.         0x504008E4,0xDFE8E0C0,0x9895AFC7,0xC0B1BFE7,0x1722181D,0x3B677058,
  395.         0x403F4F4C,0x28F2E0E7,0xE9D0A892,0xA7BFC4B4,0xB3D7FF1F,0x1A142B4F,
  396.         0x6F60443A,0x4B544008,0xE6E7F0E4,0xC0969DBB,0xC7BAADBF,0xEF131A10,
  397.         0x1B3F5F64,0x503C4756,0x4A20F8EC,0xF3F0D0A8,0x9DAFC4C0,0xAEB3D7FF,
  398.         0x150C0F2B,0x4F655840,0x3F535840,0x10F2F5F8,0xE2B89DA7,0xBFC0B0A7,
  399.         0xBFEF0B0C,0x06173F5F,0x6048414F,0x5F502000,0xF8FCF0D0,0xA49FB5BF,
  400.         0xB0A3AFCF,0xFF0A060F,0x2F556054,0x454B5B58,0x340CFCFD,0xF8E0B8A2,
  401.         0xAFBFB9A8,0xA7BFEF05,0x04051F3F,0x5D564447,0x575E4820,0x020000F0,
  402.         0xC8AAADBD,0xC0B0A3B7,0xDBFB00FD,0x0B2F5356,0x48414F5F,0x58300C04,
  403.         0x0700E0B8,0xABB9C3B8,0xA1A7BFED,0xFCF8FF1B,0x3F564C40,0x495D6040,
  404.         0x200B0B06,0xF0C8B2B6,0xBFBAA89F,0xB7DBF3F4,0xF70B2F4F,0x50424557,
  405.         0x62543011,0x0D0D00D8,0xB8B5BFC0,0xB0A0ABCF,0xEBF3F3FF,0x1F475042,
  406.         0x3D4F5F5A,0x40180C11,0x08E8C4B7,0xBFC6C0A8,0xA5BFDFF2,0xF0F70F2F,
  407.         0x4B44383F,0x575C4828,0x13131100,0xD4C0BFC6,0xC2B0A4B7,0xD7E9ECEF,
  408.         0xFF1F3D42,0x383B4F5C,0x50382013,0x180CE8CC,0xC4C9CAC0,0xA8A9C7DF,
  409.         0xE8E7F30F,0x2B3E3631,0x3F575844,0x2A1A1E1C,0x00DACCCD,0xCFC6B0A4,
  410.         0xB7D7E1E0,0xE7FD1B35,0x362E374F,0x5C503822,0x212410EC,0xD4D0D0C8,
  411.         0xB8A6ABC7,0xD9DADFEF,0x0B273430,0x33475B58,0x48322728,0x2000E0D5,
  412.         0xD3CCC0AC,0xA3B7CFD5,0xD4DFFB17,0x2D302E3F,0x5A605440,0x302E2C18,
  413.         0xF0D8D5D0,0xC4B0A0A7,0xBFCFCDD3,0xEB071F32,0x2E374F66,0x60503A31,
  414.         0x322800E0,0xD6D2C8B8,0xA29AAFC7,0xCBCBDDFB,0x172F3232,0x47656858,
  415.         0x44383430,0x14E8D6D4,0xCCBCA899,0x9FBFCBC9,0xD3EF0F2B,0x34333D5B,
  416.         0x6A604839,0x343020F8,0xD8D2D2C6,0xB2A09FB7,0xCBCECEDF,0xFF1F2F2E,
  417.         0x2F475F60,0x503A3535,0x2C0CE8D9,0xDAD4C0AA,0xA0AFBFCC,0xC8CFEF0D,
  418.         0x23272737,0x57625844,0x3A3B3820,0x00E2DFDE,0xD0B8A4A7,0xBBC7C5C6,
  419.         0xDBFB161F,0x212B475D,0x5C4C3E3F,0x403410F2,0xE7E7DCC4,0xACA5AFBF,
  420.         0xC2BDC7DF,0xFF191A1F,0x35576158,0x48424745,0x2800EEE9,0xE4D0B4A0,
  421.         0xA5B7BEB8,0xBBCFEF13,0x1A19274D,0x63615246,0x494D4014,0xF4ECE8DC,
  422.         0xC0A49DAF,0xBBB8B3BF,0xDFFF1B1A,0x1F3F5F64,0x5A4A474C,0x482000EB,
  423.         0xEAE0CCB0,0x9EA7BBBE,0xB6BFD7FB,0x161A192B,0x4F5F5848,0x41454830,
  424.         0x0AF2EFEE,0xE0C2ACAB,0xBDC6BCB7,0xCBE70712,0x0E153753,0x54463E43,
  425.         0x4B442000,0xF8FCF0D8,0xC0AFB9C5,0xC0B1B7D3,0xEF030407,0x1F3F524A,
  426.         0x40454F50,0x38180303,0x00ECCCB5,0xB7C2C0B2,0xADBFDFF7,0xFCFB0B2F,
  427.         0x474C403F,0x4F5A4C2C,0x10090C00,0xE0C0B5BF,0xC3B8A6AF,0xCBEBF7F6,
  428.         0xFD1B3F4D,0x443C475A,0x5A40200E,0x0F0CF0D0,0xB8BBC3C0,0xA8A3B7DB,
  429.         0xEFF0F307,0x2F47483C,0x3F555D50,0x30140F12,0x00E0C0BB,0xC3C2B4A4,
  430.         0xAFCFEDF1,0xF0FB1B3B,0x49403947,0x5B584020,0x0F1310F4,0xD0BFC5CB,
  431.         0xC4B0A7BF,0xDFF0EBEE,0xFF273F40,0x30374F5A,0x48301819,0x1E10E8CA,
  432.         0xCBD1CCB8,0xA6AFCBE5,0xE2DFEF0F,0x2F3B3133,0x475F5840,0x28202420,
  433.         0x00D8CBCF,0xCCC0A8A1,0xB7D7DEDB,0xE3FF1F37,0x39353F5B,0x62503425,
  434.         0x24200CE4,0xC8C9CCC0,0xA89FABC7,0xDDDDDFF7,0x17353C37,0x3F53645A,
  435.         0x40282323,0x14F0D0C7,0xCDC8B4A0,0xA3BBD7DE,0xDBE7FF2B,0x3A39394B,
  436.         0x5F644830,0x28272004,0xE0C9CDCA,0xBAA29FAF,0xC7DBD8DF,0xFB1F353A,
  437.         0x38435F69,0x58402C2A,0x2410E8CC,0xC7CDC0AC,0x9CA7BFD7,0xDCDBEF0F,
  438.         0x2F3A3639,0x4F656048,0x2C272718,0xF8D8C9CE,0xCAB8A29F,0xBBD3DEDB,
  439.         0xE7FF2535,0x34343F5B,0x60503227,0x27200AE4,0xD0D1D4C4,0xB0A4AFCB,
  440.         0xDAD9DBF3,0x0F272F2F,0x374D5E54,0x40302D28,0x1800DCD4,0xD7D0B8A8,
  441.         0xAABBD3D7,0xD5DFFF1F,0x2B2D313F,0x575C4832,0x2E2C2208,0xEAD6D9D8,
  442.         0xC0ACA8B5,0xCBD7D4D7,0xF7152327,0x2B374B5B,0x50383031,0x2A1800E2,
  443.         0xDBDED0B8,0xABAFBFCF,0xD4D3DFFF,0x1B21252F,0x3F535640,0x34343220,
  444.         0x08F0E0E0,0xDCC4B0AF,0xBAC7D1CF,0xD7EF0F1D,0x1F27374B,0x59503835,
  445.         0x38301800,0xE5E1E1D0,0xB8ABB3BF,0xCFD0CFDF,0xFF1B1F23,0x2D3F5554,
  446.         0x40313432,0x2004ECE1,0xE4E0C4B0,0xB3BFCDD3,0xD0D7F713,0x1B1C2335,
  447.         0x47524832,0x32372C14,0x00EAE8E9,0xD8C0B3BD,0xC9CFCCCC,0xDFFF1512,
  448.         0x17273F4F,0x4C38313B,0x3C2408F6,0xEEF0E8C8,0xB1B7C7CC,0xC8C6CFEF,
  449.         0x0E100D1B,0x37494E42,0x363B4438,0x1800F7F4,0xECD8B8AF,0xBDC5C2BE,
  450.         0xC5DDFF0F,0x0C132B47,0x5350423C,0x45442808,0xF8F1ECDC,0xC0A8AFBF,
  451.         0xC2BDBFD3,0xEF0F1613,0x253F5354,0x483C3D43,0x3410F5EE,0xEAE0CCB0,
  452.         0xABBFCBC7,0xC4CFEB0B,0x1B16192F,0x4B4E4438,0x30373820,0xF8EDEFEB,
  453.         0xDCC4B5BF,0xD5D4CCCF,0xDFFF1314,0x0C1B3742,0x3C30282D,0x362808F8,
  454.         0xFAFAF0E0,0xC6C3D5D9,0xCDC7D5E7,0xFF090107,0x1F393A35,0x31323D40,
  455.         0x24080303,0xFCE8D0BE,0xC7D2C8BE,0xC3D7EBFF,0x02FF1537,0x403E3B37,
  456.         0x3F473814,0x060400F0,0xD8C0BBCB,0xCABDBDCB,0xDFF70501,0x0B273F41,
  457.         0x3E3A3B44,0x40200803,0x00F4E2CA,0xBABFCEC4,0xBDC7D7EF,0xFF060517,
  458.         0x373F3E3A,0x373D4334,0x120501FC,0xF0D8C2BF,0xCFCEC2BF,0xCDDFFB03,
  459.         0x00071F3B,0x3E38353B,0x4540220C,0x0605FCE8,0xCCC0C9CF,0xC6BCBFD7,
  460.         0xEFFDFCFF,0x17333F3C,0x34374545,0x32180806,0x03F2D8C4,0xC7CECAC0,
  461.         0xBDCBE7FB,0xFDFF0D27,0x3B3D3534,0x3F463A20,0x0A0505FA,0xE0CAC7CF,
  462.         0xD0C8BEC7,0xDFF7FDFC,0x031B333C,0x342D3743,0x40281007,0x0804F0D4,
  463.         0xC8CFD7D0,0xC0BFCFED,0xFBF7F707,0x2737352B,0x2F3F4838,0x200D0D0E,
  464.         0x00E4CDCF,0xD7D4C4B9,0xBFDBEFF4,0xF0FB172F,0x38302E3B,0x4B483018,
  465.         0x11120AF4,0xD4C8CFD3,0xC8B6B7CB,0xE7F3F0F5,0x0B2B3B38,0x3037474E,
  466.         0x40201011,0x0E00E0C8,0xCBD3CEBC,0xB6BFDFF5,0xF5F5FF1F,0x3738302F,
  467.         0x3B484024,0x100D0E04,0xECD2CDD7,0xD8CCBEBF,0xD7EFF5F1,0xF70F2731,
  468.         0x2C262F3F,0x40301A12,0x131000E4,0xD6DADDD4,0xC4BFCBDF,0xEEEBEFFF,
  469.         0x17272822,0x293B4238,0x24191819,0x0CF2E0DD,0xDFDACCBD,0xBFD7E7E6,
  470.         0xE6F30B1F,0x27222335,0x43403020,0x1C1F1800,0xE8E0E2E0,0xD2C1BFCF,
  471.         0xDFE4E1E9,0xFD131F20,0x1E2B3D40,0x34281E1F,0x2010F8E6,0xE6E4DCCC,
  472.         0xC0C7D7E2,0xE0E1EFFF,0x171E1A1F,0x333F3A30,0x2420241C,0x02F0E9E8,
  473.         0xE1D6C2BE,0xCFDFDCDA,0xE5FB0F1D,0x1A192B3F,0x40362A22,0x252810F8,
  474.         0xECECE8E0,0xCCBEC7DB,0xE0D8DDEF,0xFF151A13,0x1D333E36,0x2C242226,
  475.         0x2002F0F1,0xF0E8D8CA,0xC7D5E2DC,0xD9E5F907,0x0F100F1F,0x35342925,
  476.         0x24272614,0x00F8FCF4,0xE4D4CCCF,0xDEDDD4D9,0xEFFE070A,0x0A172F37,
  477.         0x2E282A2D,0x2C200AFD,0xFFFAEAD8,0xCCCBD5D8,0xD0CFDFF3,0xFF070913,
  478.         0x27393630,0x2D2F3129,0x1400FCFA,0xF0E0D0C8,0xCED8D6D0,0xD9EFFF07,
  479.         0x0C0F1D2F,0x38302A2A,0x2C292008,0xFAFCF8E8,0xD8CFCFDB,0xDED6D7EB,
  480.         0xFB030909,0x0F23312C,0x2525272A,0x241000FF,0x00F4E4D8,0xD3DAE1D8,
  481.         0xD2DDEFFB,0x01030617,0x2B2C2425,0x292B2A1C,0x08030600,0xECE0D6D6,
  482.         0xDEDCD1D5,0xE7F4FBFF,0x030D1F2C,0x26262A2C,0x2B241404,0x0603F4E4,
  483.         0xDCD6D7DC,0xD6D2DFEF,0xF7FE0309,0x17272823,0x272B2925,0x1A0A0306,
  484.         0x00E8E0DB,0xDADEDCD5,0xDBEDF7FB,0xFF070F1F,0x28212127,0x28231C0D,
  485.         0x010500F0,0xE4E1DEDF,0xE2DCDAE7,0xF7FBFF05,0x09172320,0x1B1F2621,
  486.         0x1A120501,0x04FAEAE6,0xE5E3E4E4,0xE0E6F7FC,0xFC02090E,0x191E1817,
  487.         0x1F201812,0x0A030402,0xF4EAECEC,0xE8E7E4E3,0xEFF9F9F8,0xFF070F17,
  488.         0x18151B24,0x2018120C,0x0A0A00F0,0xEAEBE8E3,0xDEDCE3EF,0xF6F5FA03,
  489.         0x0F171D1B,0x1D262920,0x18100A07,0x02F4E6E5,0xE6E0DCDB,0xDDE7F6FA,
  490.         0xF9FF0F19,0x1F211F21,0x2A24160F,0x0A0300F8,0xE8E0E6E6,0xDEDDDFE5,
  491.         0xF5FFFCFD,0x0D171B1F,0x1C191F26,0x180C0A07,0x0200F4E6,0xE9EEE8E0,
  492.         0xE1E5EEFA,0xFAF7FF0F,0x13141616,0x1B232012,0x0F100C07,0x00F2EDF1,
  493.         0xECE1DEE0,0xE3EFF2EF,0xF5030D0F,0x15181B26,0x281C1618,0x140C04F8,
  494.         0xEEEFECE0,0xD8DBDFE5,0xEFEEEFFF,0x0E10131A,0x1F252B22,0x18191810,
  495.         0x05FCF0ED,0xEEE4D8D9,0xDFE5EDEE,0xEFFB0D12,0x14171D23,0x29221814,
  496.         0x150E04FA,0xF0EDEEE8,0xDEDBE1E7,0xEEF3F3FB,0x0B121114,0x191E2322,
  497.         0x16111310,0x04FCF6F0,0xF1F0E4DF,0xE5EBEEF2,0xF4F9030E,0x0D0D1318,
  498.         0x1C1D1810,0x11130C00,0xFCF8F7F6,0xF0E4E5EB,0xEDEEEFF1,0xF9030806,
  499.         0x0911171B,0x1A141318,0x160C0400,0xFDFBF5EA,0xE3E7E9E7,0xE8EBEFF9,
  500.         0x0202050F,0x171C1F20,0x1B1E1F15,0x0B0600FA,0xF4EAE0DE,0xE2E1DFE5,
  501.         0xEBF3FF07,0x070F1C21,0x2324211E,0x1F1A0C02,0x00F8F1EA,0xE0DADFE2,
  502.         0xE1E3EBF3,0xFF070B0E,0x171F2324,0x221C1B1A,0x1003FEF9,0xF3ECE5DD,
  503.         0xDDE3E5E6,0xEBF1FB05,0x0B0C111B,0x2020201C,0x18191508,0x00FCF8F2,
  504.         0xECE4DFE3,0xE7E7E7ED,0xF5FF070A,0x0C131E20,0x1F1C1818,0x181001FC,
  505.         0xFAF7F0E8,0xE1E1E7EA,0xE9EBF3FD,0x070C0C0F,0x1921201C,0x18161612,
  506.         0x04FCF9F8,0xF3EDE6E2,0xE7EEEEEC,0xF2FB030B,0x0C0B0F1A,0x1B181411,
  507.         0x11110A00,0xFCFBF9F6,0xF0E9EAEF,0xF0EFF1F6,0xFD050806,0x09111616,
  508.         0x14100F13,0x100600FF,0xFFFCF8F0,0xECEEF2F0,0xEEEFF7FE,0x03030207,
  509.         0x11151411,0x11131410,0x08010100,0xFCF4EDEB,0xEEEFECEC,0xEFF7FF02,
  510.         0x01050E15,0x16151314,0x16140A04,0x0000FCF6,0xF0EAECEE,0xECEDEFF6,
  511.         0xFD030306,0x0C121516,0x14121212,0x0C0400FF,0xFCF8F3ED,0xECEEEEEF,
  512.         0xF1F5FBFF,0x0406090E,0x11131211,0x100F0C08,0x0200FFFC,0xF7F4F1F0,
  513.         0xF1F2F2F5,0xF9FDFF04,0x05070B0F,0x0F10100D,0x0D0D0803,0x0100FCFB,
  514.         0xF6F0F0F3,0xF3F3F6F7,0xFC020402,0x060B0E11,0x100C0B0E,0x0D070200,
  515.         0xFEFEFBF2,0xEEF0F3F4,0xF4F4F7FF,0x05040309,0x0F121310,0x0C0F100B,
  516.         0x0300FEFD,0xFCF4ECED,0xF2F4F2F3,0xF6FD0507,0x04070F14,0x14130F0E,
  517.         0x110E04FE,0xFEFCF9F4,0xECEAEEF2,0xF1F2F6FD,0x050A090A,0x0F151614,
  518.         0x100C0D0C,0x04FEFAF9,0xF8F6F0EC,0xEFF3F5F7,0xF9FD030A,0x0A090D11,
  519.         0x1212100B,0x0A0A0500,0xFCFBF9F8,0xF4F0F1F5,0xF6F7F9FD,0x01050807,
  520.         0x090D0F0D,0x0C0B0909,0x0702FFFE,0xFEFBF8F6,0xF4F5F8F7,0xF7FAFF00,
  521.         0x03050407,0x0B0B0A0A,0x0A0A0B08,0x03010202,0x00FCF7F6,0xF8F7F5F4,
  522.         0xF6FAFEFF,0xFEFF060B,0x0C0C0D0F,0x11100C08,0x060603FD,0xF7F4F3F3,
  523.         0xF0EEEFF3,0xF9FBFDFF,0x030B0F0F,0x0F121615,0x120D0807,0x0600F6F1,
  524.         0xF0EEEEEC,0xE9EFF7FB,0xFDFF050D,0x13151413,0x1716120C,0x0500FFFC,
  525.         0xF4EEEDED,0xEEEFEFF1,0xF9FF0306,0x090E1216,0x14100F10,0x0C0701FD,
  526.         0xFBFCF8F1,0xF0F1F2F4,0xF6F6F9FF,0x06060709,0x0C0F110D,0x0A0C0C08,
  527.         0x0400FCFD,0xFDF6F2F3,0xF4F5F7F6,0xF6FE0304,0x0608090E,0x110E0A0B,
  528.         0x0B080400,0xFBFAFCF9,0xF4F3F5F6,0xF8FAF9FD,0x03070708,0x090B0E0E,
  529.         0x0A060706,0x0200FCF9,0xF9FBF9F6,0xF7F9FBFD,0xFFFF0307,0x09090808,
  530.         0x08080704,0x010000FE,0xFCFBFBFC,0xFEFEFEFF,0x00010202,0x03030303,
  531.         0x02000000,0xFF000000,0x00010203,0x03030305,0x040100FF,0xFDFDFDFC,
  532.         0xFAFCFEFE,0xFFFFFF03,0x07070709,0x0A090A08,0x03030300,0xFBF8F6F5
  533.     };
  534.  
  535.     struct IOAudio    *AudioBlock;
  536.     struct MsgPort    *ReplyPort;
  537.  
  538.     if(AudioBlock = (struct IOAudio *)AllocMem(sizeof(struct IOAudio),MEMF_PUBLIC | MEMF_CLEAR))
  539.     {
  540.         if(ReplyPort = (struct MsgPort *)CreatePort(NULL,0))
  541.         {
  542.             AudioBlock -> ioa_Data                        = &AnyChannel[0];
  543.             AudioBlock -> ioa_Length                    = 4;
  544.             AudioBlock -> ioa_Request . io_Message . mn_ReplyPort        = ReplyPort;
  545.             AudioBlock -> ioa_Request . io_Message . mn_Node . ln_Pri    = 90;
  546.  
  547.             if(!OpenDevice("audio.device",0,AudioBlock,0))
  548.             {
  549.                 AudioBlock -> ioa_Request . io_Command    = CMD_WRITE;
  550.                 AudioBlock -> ioa_Request . io_Flags    = ADIOF_PERVOL;
  551.                 AudioBlock -> ioa_Period        = 428;
  552.                 AudioBlock -> ioa_Volume        = 64;
  553.                 AudioBlock -> ioa_Cycles        = 3;
  554.                 AudioBlock -> ioa_Data            = (UBYTE *)&SoundData[0];
  555.                 AudioBlock -> ioa_Length        = 4344;
  556.  
  557.                 BeginIO(AudioBlock);
  558.                 WaitIO(AudioBlock);
  559.                 AbortIO(AudioBlock);
  560.  
  561.                 CloseDevice(AudioBlock);
  562.             }
  563.  
  564.             DeletePort(ReplyPort);
  565.         }
  566.  
  567.         FreeMem(AudioBlock,sizeof(struct IOAudio));
  568.     }
  569. }
  570.  
  571.     /* DoBlockCrc(Mem,Size):
  572.      *
  573.      *    Calculates the 16-Bit CRC value for a given
  574.      *    memory block.
  575.      */
  576.  
  577. LONG __regargs
  578. DoBlockCrc(Mem,Size)
  579. register UBYTE *Mem;
  580. register LONG Size;
  581. {
  582.     /* crctab calculated by Mark G. Mendel, Network Systems Corporation */
  583.  
  584.     static const unsigned short crctab[256] =
  585.     {
  586.         0x0000,0x1021,0x2042,0x3063,0x4084,0x50A5,0x60C6,0x70E7,
  587.         0x8108,0x9129,0xA14A,0xB16B,0xC18C,0xD1AD,0xE1CE,0xF1EF,
  588.         0x1231,0x0210,0x3273,0x2252,0x52B5,0x4294,0x72F7,0x62D6,
  589.         0x9339,0x8318,0xB37B,0xA35A,0xD3BD,0xC39C,0xF3FF,0xE3DE,
  590.         0x2462,0x3443,0x0420,0x1401,0x64E6,0x74C7,0x44A4,0x5485,
  591.         0xA56A,0xB54B,0x8528,0x9509,0xE5EE,0xF5CF,0xC5AC,0xD58D,
  592.         0x3653,0x2672,0x1611,0x0630,0x76D7,0x66F6,0x5695,0x46B4,
  593.         0xB75B,0xA77A,0x9719,0x8738,0xF7DF,0xE7FE,0xD79D,0xC7BC,
  594.         0x48C4,0x58E5,0x6886,0x78A7,0x0840,0x1861,0x2802,0x3823,
  595.         0xC9CC,0xD9ED,0xE98E,0xF9AF,0x8948,0x9969,0xA90A,0xB92B,
  596.         0x5AF5,0x4AD4,0x7AB7,0x6A96,0x1A71,0x0A50,0x3A33,0x2A12,
  597.         0xDBFD,0xCBDC,0xFBBF,0xEB9E,0x9B79,0x8B58,0xBB3B,0xAB1A,
  598.         0x6CA6,0x7C87,0x4CE4,0x5CC5,0x2C22,0x3C03,0x0C60,0x1C41,
  599.         0xEDAE,0xFD8F,0xCDEC,0xDDCD,0xAD2A,0xBD0B,0x8D68,0x9D49,
  600.         0x7E97,0x6EB6,0x5ED5,0x4EF4,0x3E13,0x2E32,0x1E51,0x0E70,
  601.         0xFF9F,0xEFBE,0xDFDD,0xCFFC,0xBF1B,0xAF3A,0x9F59,0x8F78,
  602.         0x9188,0x81A9,0xB1CA,0xA1EB,0xD10C,0xC12D,0xF14E,0xE16F,
  603.         0x1080,0x00A1,0x30C2,0x20E3,0x5004,0x4025,0x7046,0x6067,
  604.         0x83B9,0x9398,0xA3FB,0xB3DA,0xC33D,0xD31C,0xE37F,0xF35E,
  605.         0x02B1,0x1290,0x22F3,0x32D2,0x4235,0x5214,0x6277,0x7256,
  606.         0xB5EA,0xA5CB,0x95A8,0x8589,0xF56E,0xE54F,0xD52C,0xC50D,
  607.         0x34E2,0x24C3,0x14A0,0x0481,0x7466,0x6447,0x5424,0x4405,
  608.         0xA7DB,0xB7FA,0x8799,0x97B8,0xE75F,0xF77E,0xC71D,0xD73C,
  609.         0x26D3,0x36F2,0x0691,0x16B0,0x6657,0x7676,0x4615,0x5634,
  610.         0xD94C,0xC96D,0xF90E,0xE92F,0x99C8,0x89E9,0xB98A,0xA9AB,
  611.         0x5844,0x4865,0x7806,0x6827,0x18C0,0x08E1,0x3882,0x28A3,
  612.         0xCB7D,0xDB5C,0xEB3F,0xFB1E,0x8BF9,0x9BD8,0xABBB,0xBB9A,
  613.         0x4A75,0x5A54,0x6A37,0x7A16,0x0AF1,0x1AD0,0x2AB3,0x3A92,
  614.         0xFD2E,0xED0F,0xDD6C,0xCD4D,0xBDAA,0xAD8B,0x9DE8,0x8DC9,
  615.         0x7C26,0x6C07,0x5C64,0x4C45,0x3CA2,0x2C83,0x1CE0,0x0CC1,
  616.         0xEF1F,0xFF3E,0xCF5D,0xDF7C,0xAF9B,0xBFBA,0x8FD9,0x9FF8,
  617.         0x6E17,0x7E36,0x4E55,0x5E74,0x2E93,0x3EB2,0x0ED1,0x1EF0
  618.     };
  619.  
  620.     register unsigned short crc = 0;
  621.  
  622.     /*
  623.      * updcrc macro derived from article Copyright (C) 1986 Stephen Satchell.
  624.      *  NOTE: First argument must be in range 0 to 255.
  625.      *        Second argument is referenced twice.
  626.      *
  627.      * Programmers may incorporate any or all code into their programs,
  628.      * giving proper credit within the source. Publication of the
  629.      * source routines is permitted so LONG as proper credit is given
  630.      * to Stephen Satchell, Satchell Evaluations and Chuck Forsberg,
  631.      * Omen Technology.
  632.      */
  633.  
  634.     while(Size-- > 0)
  635.         crc = crctab[((crc >> 8) & 255)] ^ (crc << 8) ^ *Mem++;
  636.  
  637.     return((LONG)crc);
  638. }
  639.  
  640.     /* Inhibit(DriveID,Code):
  641.      *
  642.      *    Gives the Disk-Validator access to a disk drive
  643.      *    or doesn't.
  644.      */
  645.  
  646. LONG
  647. Inhibit(DriveID,Code)
  648. char *DriveID;
  649. LONG Code;
  650. {
  651.     struct MsgPort    *HandlerTask;
  652.     LONG         Args[7];
  653.  
  654.     if(!(HandlerTask = (struct MsgPort *)DeviceProc(DriveID)))
  655.         return(FALSE);
  656.  
  657.     Args[0] = Code;
  658.  
  659.     return(SendPacket(ACTION_INHIBIT,Args,HandlerTask));
  660. }
  661.  
  662.     /* B2C(to,from):
  663.      *
  664.      *    Converts a BSTR into a 'C'-String.
  665.      */
  666.  
  667. UBYTE *
  668. B2C(to,from)
  669. UBYTE *to;
  670. BSTR from;
  671. {
  672.     UBYTE length = *((UBYTE *)BADDR(from));
  673.     UBYTE *src = (UBYTE *)BADDR(from) + 1;
  674.  
  675.     while(length--)
  676.         *to++ = *src++;
  677.  
  678.     *to = NULL;
  679.  
  680.     return(to);
  681. }
  682.  
  683.     /* DriverAction(Command,Dest,Track):
  684.      *
  685.      *    Lets the current unit driver take some action.
  686.      */
  687.  
  688. LONG
  689. DriverAction(Command,Dest,Track)
  690. LONG Command,*Dest,Track;
  691. {
  692.     DiskRequest -> iotd_Req . io_Command    = Command;
  693.     DiskRequest -> iotd_Req . io_Length    = TRACKSIZE;
  694.     DiskRequest -> iotd_Req . io_Data    = (APTR)Dest;
  695.     DiskRequest -> iotd_Req . io_Offset    = Track * TRACKSIZE;
  696.  
  697.     DiskRequest -> iotd_SecLabel        = (ULONG)Dest + TRACKSIZE;
  698.  
  699.     DoIO(DiskRequest);
  700.  
  701.     return((LONG)DiskRequest -> iotd_Req . io_Error);
  702. }
  703.  
  704.     /* ClearMem(Mem,Size):
  705.      *
  706.      *    Sets a block of memory to zero.
  707.      */
  708.  
  709. VOID __regargs
  710. ClearMem(Mem,Size)
  711. register char *Mem;
  712. register LONG Size;
  713. {
  714.     while(Size-- > 0)
  715.         *Mem++ = 0;
  716. }
  717.  
  718.     /* ClearTrack(Track,Number):
  719.      *
  720.      *    Clears unused blocks in a disk track.
  721.      */
  722.  
  723. VOID __regargs
  724. ClearTrack(Track,Number)
  725. UBYTE *Track;
  726. LONG Number;
  727. {
  728.     register LONG i;
  729.  
  730.     for(i = 0 ; i < 22 ; i++)
  731.         if(!BlockTab[Number * 22 + i])
  732.             ClearMem(&Track[i * TD_SECTOR],TD_SECTOR);
  733. }
  734.  
  735.     /* CheckSum(DiskSector):
  736.      *
  737.      *    Calculates the DOS-checksum for a track.
  738.      */
  739.  
  740. ULONG __regargs
  741. CheckSum(DiskSector)
  742. ULONG *DiskSector;
  743. {
  744.     ULONG Sum;
  745.     SHORT i;
  746.  
  747.     for(Sum = 0, i = 0 ; i < TD_SECTOR / 4 ; i++)
  748.         Sum += DiskSector[i];
  749.  
  750.     return(Sum);
  751. }
  752.  
  753.     /* GetBitmap(CompInfo):
  754.      *
  755.      *    Reads the bitmap of disk and checks if it has
  756.      *    a root-block.
  757.      */
  758.  
  759. LONG
  760. GetBitmap(CompInfo)
  761. struct CompInfo *CompInfo;
  762. {
  763.     LONG Error;
  764.     register SHORT i;
  765.     BYTE Answer[256];
  766.  
  767.     DiskRequest -> iotd_Req . io_Command    = TD_MOTOR;
  768.     DiskRequest -> iotd_Req . io_Length    = 1;
  769.     DoIO(DiskRequest);
  770.  
  771.         /* Read first sector. */
  772.  
  773.     DiskRequest -> iotd_Req . io_Command    = ETD_READ;
  774.     DiskRequest -> iotd_Req . io_Length    = TD_SECTOR;
  775.     DiskRequest -> iotd_Req . io_Data    = (APTR)ChipSector;
  776.     DiskRequest -> iotd_Req . io_Offset    = 0;
  777.  
  778.     if(Error = DoIO(DiskRequest))
  779.     {
  780.         if(Window)
  781.             SimpleRequest("Device error Nº %ld!\n",Error);
  782.         else
  783.             Printf("Device error Nº %ld!\a\n",Error);
  784.  
  785.         return(FALSE);
  786.     }
  787.  
  788.         /* Not a standard DOS disk? */
  789.  
  790.     if((ULONG)ChipSector[0] != ID_DOS_DISK)
  791.     {
  792.             /* No bitmap available. */
  793.  
  794.         ClearBlocks = FALSE;
  795.  
  796.             /* Not a fast file system disk? */
  797.  
  798.         if((ULONG)ChipSector[0] != ID_FFS_DISK)
  799.         {
  800.                 /* Ask if we are to continue. */
  801.  
  802.             if(Window)
  803.             {
  804.                 if(!TwoGadRequest("That's  not a standard DOS disk,\ndo you want to continue?"))
  805.                     return(FALSE);
  806.             }
  807.             else
  808.             {
  809.                 Printf("That's not a standard DOS disk, do you want to continue (y/N) ? ");
  810.  
  811.                 Read(Input(),Answer,255);
  812.  
  813.                 if(Toupper(Answer[0]) != 'Y')
  814.                     return(FALSE);
  815.             }
  816.         }
  817.  
  818.         return(TRUE);
  819.     }
  820.  
  821.         /* Read the root-block. */
  822.  
  823.     DiskRequest -> iotd_Req . io_Command    = ETD_READ;
  824.     DiskRequest -> iotd_Req . io_Length    = TD_SECTOR;
  825.     DiskRequest -> iotd_Req . io_Data    = (APTR)ChipSector;
  826.     DiskRequest -> iotd_Req . io_Offset    = ROOTBLOCK * TD_SECTOR;
  827.  
  828.     if(Error = DoIO(DiskRequest))
  829.     {
  830.         if(Window)
  831.             SimpleRequest("Device error Nº %ld!\n",Error);
  832.         else
  833.             Printf("Device error Nº %ld!\a\n",Error);
  834.  
  835.         return(FALSE);
  836.     }
  837.  
  838.         /* If checksum is zero and the block types are okay,
  839.          * this disk has a root-block.
  840.          */
  841.  
  842.     if(ChipSector[0] == 2 && ChipSector[127] == 1 && !CheckSum((ULONG *)ChipSector))
  843.         CompInfo -> ci_ExtFlags |= CI_HASROOT;
  844.  
  845.         /* If this longword is DOSTRUE, bitmap is valid. */
  846.  
  847.     if(ChipSector[78] != DOSTRUE)
  848.     {
  849.         ClearBlocks = FALSE;
  850.  
  851.         if(!Window)
  852.             Puts("\2331A\33[1m\33[33mWarning:\33[31m\33[0m Disk is not validated, unused blocks are not cleared!\n\n");
  853.  
  854.         return(TRUE);
  855.     }
  856.  
  857.         /* Read the bitmap block. */
  858.  
  859.     DiskRequest -> iotd_Req . io_Command    = ETD_READ;
  860.     DiskRequest -> iotd_Req . io_Length    = TD_SECTOR;
  861.     DiskRequest -> iotd_Req . io_Data    = (APTR)ChipSector;
  862.     DiskRequest -> iotd_Req . io_Offset    = (ChipSector[79]) * TD_SECTOR;
  863.  
  864.     if(Error = DoIO(DiskRequest))
  865.     {
  866.         if(Window)
  867.             SimpleRequest("Device error Nº %ld!\n",Error);
  868.         else
  869.             Printf("Device error Nº %ld!\a\n",Error);
  870.  
  871.         return(FALSE);
  872.     }
  873.  
  874.         /* Build an array of boolean values describing the
  875.          * state of available blocks.
  876.          */
  877.  
  878.     for(i = 0 ; i < 1760 ; i++)
  879.     {
  880.         if(ChipSector[1 + i / 32] & (1 << (i % 32)))
  881.             BlockTab[i + 2] = FALSE;
  882.         else
  883.             BlockTab[i + 2] = TRUE;
  884.     }
  885.  
  886.         /* The first two blocks are usually reserved. */
  887.  
  888.     BlockTab[0] = BlockTab[1] = TRUE;
  889.  
  890.     return(TRUE);
  891. }
  892.  
  893.     /* MakeID(IDString):
  894.      *
  895.      *    Turns a 4 char string into a longword ID.
  896.      */
  897.  
  898. LONG
  899. MakeID(IDString)
  900. char *IDString;
  901. {
  902.     register LONG LongID;
  903.  
  904.     LongID = (IDString[0] << 24) | (IDString[1] << 16) | (IDString[2] << 8) | (IDString[3]);
  905.  
  906.     return(LongID);
  907. }
  908.  
  909.     /* GetFileSize(Name):
  910.      *
  911.      *    Returns the length of a file.
  912.      */
  913.  
  914. LONG
  915. GetFileSize(Name)
  916. char *Name;
  917. {
  918.     struct FileInfoBlock    *FileInfo;
  919.     BPTR             FileLock;
  920.     LONG             FileSize = 0;
  921.  
  922.     if(FileInfo = (struct FileInfoBlock *)AllocMem(sizeof(struct FileInfoBlock),MEMF_PUBLIC))
  923.     {
  924.         if(FileLock = Lock(Name,ACCESS_READ))
  925.         {
  926.             Examine(FileLock,FileInfo);
  927.  
  928.             FileSize = FileInfo -> fib_Size;
  929.  
  930.             UnLock(FileLock);
  931.         }
  932.  
  933.         FreeMem(FileInfo,sizeof(struct FileInfoBlock));
  934.     }
  935.  
  936.     return(FileSize);
  937. }
  938.  
  939.     /* WriteDump(FileName,Unit):
  940.      *
  941.      *    The main compression routine.
  942.      */
  943.  
  944. LONG
  945. ReadDump(FileName,Unit)
  946. char *FileName,*Unit;
  947. {
  948.     LONG                *Buffer,i,CrunchLength,Error,Success = TRUE;
  949.     BPTR                 DumpFile;
  950.     char                 TempString[40];
  951.     extern struct DosLibrary    *DOSBase;
  952.     struct DeviceNode        *DeviceNode;
  953.     struct FileSysStartupMsg    *FileMsg;
  954.     UBYTE                 Name[108],DevName[108];
  955.     struct CompInfo             CompInfo;
  956.     unsigned short             TrackCRC;
  957.     struct TRStructure         MyTextStruct;
  958.     char                 QuestText[40];
  959.     BOOL                 Result,HasFast;
  960.  
  961.         /* First issue: try to find the DOS-Node of the unit
  962.          * driver.
  963.          */
  964.  
  965.     strcpy(DevName,Unit);
  966.  
  967.     for(i = 0 ; i < strlen(DevName) ; i++)
  968.     {
  969.         if(DevName[i] == ':')
  970.             DevName[i] = 0;
  971.     }
  972.  
  973.         /* Some nice casting. */
  974.  
  975.     DeviceNode = (struct DeviceNode *)BADDR(((struct DosInfo *)BADDR(((struct RootNode *)DOSBase -> dl_Root) -> rn_Info)) -> di_DevInfo);
  976.  
  977.     while(DeviceNode)
  978.     {
  979.         B2C(Name,DeviceNode -> dn_Name);
  980.  
  981.             /* Is it the name we want? */
  982.  
  983.         if(!Strcmp(Name,DevName) && (FileMsg = (struct FileSysStartupMsg *)BADDR(DeviceNode -> dn_Startup)))
  984.             goto FoundIt;
  985.  
  986.         DeviceNode = (struct DeviceNode *)BADDR(DeviceNode -> dn_Next);
  987.     }
  988.  
  989.         /* Didn't find the driver. */
  990.  
  991.     if(Window)
  992.         SimpleRequest("Couldn't find driver %s:.",DevName);
  993.     else
  994.         Printf("Couldn't find driver %s:.\a\n",DevName);
  995.  
  996.     return(FALSE);
  997.  
  998.         /* Go along with the driver initialization. */
  999.  
  1000. FoundIt:if(!(DiskPort = (struct MsgPort *)CreatePort(NULL,0)))
  1001.     {
  1002.         if(Window)
  1003.             SimpleRequest("Couldn't create port.");
  1004.         else
  1005.             Puts("Couldn't create port.\a");
  1006.  
  1007.         return(FALSE);
  1008.     }
  1009.  
  1010.     if(!(DiskRequest = (struct IOExtTD *)CreateExtIO(DiskPort,sizeof(struct IOExtTD))))
  1011.     {
  1012.         DeletePort(DiskPort);
  1013.  
  1014.         if(Window)
  1015.             SimpleRequest("Couldn't create device buffer.");
  1016.         else
  1017.             Puts("Couldn't create device buffer.\a");
  1018.  
  1019.         return(FALSE);
  1020.     }
  1021.  
  1022.     B2C(Name,FileMsg -> fssm_Device);
  1023.  
  1024.     if(OpenDevice(Name,FileMsg -> fssm_Unit,DiskRequest,0))
  1025.     {
  1026.         DeleteExtIO(DiskRequest);
  1027.         DeletePort(DiskPort);
  1028.  
  1029.         if(Window)
  1030.             SimpleRequest("Couldn't open unit driver.");
  1031.         else
  1032.             Puts("Couldn't open unit driver.\a");
  1033.  
  1034.         return(FALSE);
  1035.     }
  1036.  
  1037.     if(!(ChipSector = (LONG *)AllocMem(EXTRASIZE,MEMF_CHIP | MEMF_CLEAR)))
  1038.     {
  1039.         CloseDevice(DiskRequest);
  1040.         DeleteExtIO(DiskRequest);
  1041.         DeletePort(DiskPort);
  1042.  
  1043.         if(Window)
  1044.             SimpleRequest("Couldn't allocate sector buffer.");
  1045.         else
  1046.             Puts("Couldn't allocate sector buffer.\a");
  1047.  
  1048.         return(FALSE);
  1049.     }
  1050.  
  1051.     if(!(Sector = (LONG *)AllocMem(EXTRASIZE,MEMF_FAST)))
  1052.     {
  1053.         HasFast = FALSE;
  1054.         Sector = ChipSector;
  1055.     }
  1056.     else
  1057.         HasFast = TRUE;
  1058.  
  1059.     if(!(Buffer = (LONG *)AllocMem(EXTRASIZE,MEMF_PUBLIC | MEMF_CLEAR)))
  1060.     {
  1061.         if(HasFast)
  1062.             FreeMem(Sector,EXTRASIZE);
  1063.  
  1064.         FreeMem(ChipSector,EXTRASIZE);
  1065.         CloseDevice(DiskRequest);
  1066.         DeleteExtIO(DiskRequest);
  1067.         DeletePort(DiskPort);
  1068.  
  1069.         if(Window)
  1070.             SimpleRequest("Couldn't allocate sector buffer.");
  1071.         else
  1072.             Puts("Couldn't allocate sector buffer.\a");
  1073.  
  1074.         return(FALSE);
  1075.     }
  1076.  
  1077.     DiskRequest -> iotd_Req . io_Command = TD_CHANGESTATE;
  1078.     DoIO(DiskRequest);
  1079.  
  1080.     if(DiskRequest -> iotd_Req . io_Actual)
  1081.     {
  1082.         if(HasFast)
  1083.             FreeMem(Sector,EXTRASIZE);
  1084.  
  1085.         FreeMem(Buffer,EXTRASIZE);
  1086.         FreeMem(ChipSector,EXTRASIZE);
  1087.         CloseDevice(DiskRequest);
  1088.         DeleteExtIO(DiskRequest);
  1089.         DeletePort(DiskPort);
  1090.  
  1091.         if(Window)
  1092.             SimpleRequest("No disk in unit.");
  1093.         else
  1094.             Puts("No disk in unit.\a");
  1095.  
  1096.         return(FALSE);
  1097.     }
  1098.  
  1099.     DiskRequest -> iotd_Req . io_Command = TD_CHANGENUM;
  1100.     DoIO(DiskRequest);
  1101.  
  1102.     DiskRequest -> iotd_Count = DiskRequest -> iotd_Req . io_Actual;
  1103.  
  1104.     if(!Inhibit(Unit,DOSTRUE))
  1105.     {
  1106.         if(HasFast)
  1107.             FreeMem(Sector,EXTRASIZE);
  1108.  
  1109.         FreeMem(Buffer,EXTRASIZE);
  1110.         FreeMem(ChipSector,EXTRASIZE);
  1111.         CloseDevice(DiskRequest);
  1112.         DeleteExtIO(DiskRequest);
  1113.         DeletePort(DiskPort);
  1114.  
  1115.         if(Window)
  1116.             SimpleRequest("Can't inhibit unit driver.");
  1117.         else
  1118.             Puts("Can't inhibit unit driver.\a");
  1119.  
  1120.         return(FALSE);
  1121.     }
  1122.  
  1123.         /* Open the dump file. */
  1124.  
  1125.     if(!(DumpFile = Open(FileName,MODE_NEWFILE)))
  1126.     {
  1127.         if(HasFast)
  1128.             FreeMem(Sector,EXTRASIZE);
  1129.  
  1130.         Inhibit(Unit,DOSFALSE);
  1131.         FreeMem(Buffer,EXTRASIZE);
  1132.         FreeMem(ChipSector,EXTRASIZE);
  1133.         CloseDevice(DiskRequest);
  1134.         DeleteExtIO(DiskRequest);
  1135.         DeletePort(DiskPort);
  1136.  
  1137.         if(Window)
  1138.             SimpleRequest("Couldn't create dump file.");
  1139.         else
  1140.             Puts("Couldn't create dump file.\a");
  1141.  
  1142.         return(FALSE);
  1143.     }
  1144.  
  1145.         /* Create the compression auxiliary buffers. */
  1146.  
  1147.     if(!compinit())
  1148.     {
  1149.         if(HasFast)
  1150.             FreeMem(Sector,EXTRASIZE);
  1151.  
  1152.         Close(DumpFile);
  1153.         Inhibit(Unit,DOSFALSE);
  1154.         FreeMem(Buffer,EXTRASIZE);
  1155.         FreeMem(ChipSector,EXTRASIZE);
  1156.         CloseDevice(DiskRequest);
  1157.         DeleteExtIO(DiskRequest);
  1158.         DeletePort(DiskPort);
  1159.  
  1160.         if(Window)
  1161.             SimpleRequest("Not enough memory for packer buffer.");
  1162.         else
  1163.             Puts("Not enough memory for packer buffer.\a");
  1164.  
  1165.         return(FALSE);
  1166.     }
  1167.  
  1168.         /* Initialize the dump file header. */
  1169.  
  1170.     CompInfo . ci_ProgramID        = MakeID(PROGRAMID);
  1171.     CompInfo . ci_Version        = PRGVERSION;
  1172.     CompInfo . ci_Compression    = 1;
  1173.     CompInfo . ci_ExtFlags        = 0;
  1174.  
  1175.         /* Check the bitmap. */
  1176.  
  1177.     if(!GetBitmap(&CompInfo))
  1178.         goto Sneak;
  1179.  
  1180.         /* Write the header. */
  1181.  
  1182.     if(Write(DumpFile,&CompInfo,sizeof(struct CompInfo)) != sizeof(struct CompInfo))
  1183.     {
  1184.         if(!Window)
  1185.             Puts("Error writing dump file.\a");
  1186.         else
  1187.             SimpleRequest("Error writing dump file.");
  1188.  
  1189.         Success = FALSE;
  1190.  
  1191.         goto Sneak;
  1192.     }
  1193.  
  1194.         /* Begin the compression. */
  1195.  
  1196. Loop:    for(i = 0 ; i < 80 ; i++)
  1197.     {
  1198.             /* Update window. */
  1199.  
  1200.         if(Window)
  1201.         {
  1202.             SPrintf(TempString,"%02ld/%02ld",i,79 - i);
  1203.  
  1204.             Move(RPort,151,76);
  1205.             Punch(TempString);
  1206.  
  1207.             Move(RPort,100,85);
  1208.             Punch("Read ");
  1209.  
  1210.             Move(RPort,151,85);
  1211.             Punch("11296");
  1212.  
  1213.             if(Massage = (struct IntuiMessage *)GetMsg(Window -> UserPort))
  1214.             {
  1215.                 Class    = Massage -> Class;
  1216.                 Gadget    = (struct Gadget *)Massage -> IAddress;
  1217.  
  1218.                 ReplyMsg((struct Message *)Massage);
  1219.  
  1220.                 if(Class == GADGETUP && Gadget -> GadgetID == DriveWanted)
  1221.                 {
  1222.                     if(TwoGadRequest("Really stop compressing from drive %s: ?",DevName))
  1223.                     {
  1224.                         Success = FALSE;
  1225.                         goto Sneak;
  1226.                     }
  1227.                 }
  1228.             }
  1229.         }
  1230.         else
  1231.         {
  1232.             Printf("\2331ATrack %02ld, \233K",i);
  1233.  
  1234.             if(SetSignal(0,0) & SIGBREAKF_CTRL_C)
  1235.             {
  1236.                 Puts("\n*** Break: CompDisk\a");
  1237.                 SetSignal(0,SIGBREAKF_CTRL_C);
  1238.  
  1239.                 Success = FALSE;
  1240.  
  1241.                 goto Sneak;
  1242.             }
  1243.         }
  1244.  
  1245.             /* Read the track. */
  1246.  
  1247. Retry:        if(Error = DriverAction(ETD_READ,ChipSector,i))
  1248.         {
  1249.             MyTextStruct . Text        = QuestText;
  1250.             MyTextStruct . Window        = 0;
  1251.             MyTextStruct . MiddleText    = "Retry";
  1252.             MyTextStruct . PositiveText    = "Ok";
  1253.             MyTextStruct . NegativeText    = "Cancel";
  1254.             MyTextStruct . Title        = "System Request";
  1255.             MyTextStruct . KeyMask        = AMIGAKEYS;
  1256.             MyTextStruct . textcolor    = 1;
  1257.             MyTextStruct . detailcolor    = 0;
  1258.             MyTextStruct . blockcolor    = 1;
  1259.             MyTextStruct . versionnumber    = 0;
  1260.             MyTextStruct . rfu1        = 0;
  1261.             MyTextStruct . rfu2        = 0;
  1262.  
  1263.             SPrintf(QuestText,"Device error Nº %ld! Do you wish to continue?",Error);
  1264.  
  1265.             if(Window)
  1266.             {
  1267.                 Result = TextRequest(&MyTextStruct);
  1268.  
  1269.                 switch(Result)
  1270.                 {
  1271.                         /* Ignore. */
  1272.  
  1273.                     case 2:    goto GoOn;
  1274.  
  1275.                         /* Retry. */
  1276.  
  1277.                     case 1:    goto Retry;
  1278.  
  1279.                         /* Cancel. */
  1280.  
  1281.                     case 0:    Success = FALSE;
  1282.                         goto Sneak;
  1283.                 }
  1284.             }
  1285.             else
  1286.             {
  1287.                 Printf("Device error Nº %ld! Do you wish to continue ([r]etry/[i]gnore/[C]ancel) ? \a",Error);
  1288.  
  1289.                 Read(Input(),QuestText,39);
  1290.  
  1291.                 switch(Toupper(QuestText[0]))
  1292.                 {
  1293.                         /* Ignore. */
  1294.  
  1295.                     case 'I':    goto GoOn;
  1296.  
  1297.                         /* Retry. */
  1298.  
  1299.                     case 'R':    goto Retry;
  1300.  
  1301.                         /* Cancel */
  1302.  
  1303.                     default:    Success = FALSE;
  1304.                             goto Sneak;
  1305.                 }
  1306.             }
  1307.         }
  1308.  
  1309. GoOn:        if(Window)
  1310.         {
  1311.             Move(RPort,100,85);
  1312.             Punch("Check");
  1313.         }
  1314.         else
  1315.             Printf("checking, ");
  1316.  
  1317.             /* Push the block over... */
  1318.  
  1319.         if(HasFast)
  1320.             CopyMemQuick(ChipSector,Sector,EXTRASIZE);
  1321.  
  1322.             /* Clear unused blocks if necessary. */
  1323.  
  1324.         if(ClearBlocks)
  1325.             ClearTrack((UBYTE *)Sector,i);
  1326.  
  1327.             /* Calculate the CRC value for this track. */
  1328.  
  1329.         TrackCRC = DoBlockCrc((UBYTE *)Sector,EXTRASIZE);
  1330.  
  1331.         if(!Window)
  1332.             Printf("packing... ");
  1333.         else
  1334.         {
  1335.             Move(RPort,100,85);
  1336.             Punch("Pack ");
  1337.         }
  1338.             
  1339.             /* Compress the track. */
  1340.  
  1341.         CrunchLength = compfiles((char *)Sector,EXTRASIZE,(char *)Buffer,EXTRASIZE);
  1342.  
  1343.         if(!Window)
  1344.             Printf("%ld, ",CrunchLength);
  1345.  
  1346.             /* Not a good result, we'll store the data as is. */
  1347.  
  1348.         if(CrunchLength < 1 || CrunchLength >= EXTRASIZE)
  1349.             CrunchLength = 0;
  1350.  
  1351.         if(Window)
  1352.         {
  1353.             Move(RPort,100,85);
  1354.             Punch("Write ");
  1355.  
  1356.             Move(RPort,151,85);
  1357.  
  1358.             SPrintf(TempString,"%5ld",(CrunchLength) ? CrunchLength : 11264);
  1359.             Punch(TempString);
  1360.         }
  1361.         else
  1362.             Printf("writing...\n");
  1363.  
  1364.             /* Write the length of the track. */
  1365.  
  1366.         if(Write(DumpFile,&CrunchLength,sizeof(LONG)) != sizeof(LONG))
  1367.         {
  1368.             if(!Window)
  1369.                 Puts("Error writing dump file.\a");
  1370.             else
  1371.                 SimpleRequest("Error writing dump file.");
  1372.  
  1373.             Success = FALSE;
  1374.  
  1375.             break;
  1376.         }
  1377.  
  1378.             /* Write the CRC value. */
  1379.  
  1380.         if(Write(DumpFile,&TrackCRC,sizeof(unsigned short)) != sizeof(unsigned short))
  1381.         {
  1382.             if(!Window)
  1383.                 Puts("Error writing dump file.\a");
  1384.             else
  1385.                 SimpleRequest("Error writing dump file.");
  1386.  
  1387.             Success = FALSE;
  1388.  
  1389.             break;
  1390.         }
  1391.  
  1392.             /* Write the compressed data if necessary. */
  1393.  
  1394.         if(CrunchLength)
  1395.         {
  1396.             if(Write(DumpFile,Buffer,CrunchLength) != CrunchLength)
  1397.             {
  1398.                 if(!Window)
  1399.                     Puts("Error writing dump file.\a");
  1400.                 else
  1401.                     SimpleRequest("Error writing dump file.");
  1402.  
  1403.                 Success = FALSE;
  1404.  
  1405.                 break;
  1406.             }
  1407.         }
  1408.         else
  1409.         {
  1410.                 /* Write the data as is. */
  1411.  
  1412.             if(Write(DumpFile,Sector,EXTRASIZE) != EXTRASIZE)
  1413.             {
  1414.                 if(!Window)
  1415.                     Puts("Error writing dump file.\a");
  1416.                 else
  1417.                     SimpleRequest("Error writing dump file.");
  1418.  
  1419.                 Success = FALSE;
  1420.                 break;
  1421.             }
  1422.         }
  1423.     }
  1424.  
  1425.         /* Close the file. */
  1426.  
  1427. Sneak:    Close(DumpFile);
  1428.  
  1429.         /* Turn the motor off. */
  1430.  
  1431.     DiskRequest -> iotd_Req . io_Command    = TD_MOTOR;
  1432.     DiskRequest -> iotd_Req . io_Length    = 0;
  1433.  
  1434.     DoIO(DiskRequest);
  1435.  
  1436.         /* Free the resources. */
  1437.  
  1438.     CloseDevice(DiskRequest);
  1439.     DeleteExtIO(DiskRequest);
  1440.     DeletePort(DiskPort);
  1441.  
  1442.     FreeMem(Buffer,EXTRASIZE);
  1443.     FreeMem(ChipSector,EXTRASIZE);
  1444.  
  1445.     if(HasFast)
  1446.         FreeMem(Sector,EXTRASIZE);
  1447.  
  1448.     Inhibit(Unit,DOSFALSE);
  1449.  
  1450.     compexit();
  1451.  
  1452.     return(Success);
  1453. }
  1454.  
  1455.     /* FindDevice(DevName):
  1456.      *
  1457.      *    Tries to find a device, returns true if successful.
  1458.      */
  1459.  
  1460. LONG
  1461. FindDevice(DevName)
  1462. char *DevName;
  1463. {
  1464.     char                *Pointer,Name[257];
  1465.     extern struct DosLibrary    *DOSBase;
  1466.     register struct DeviceNode    *DevInfo;
  1467.     struct RootNode            *RootNode = (struct RootNode *)DOSBase -> dl_Root;
  1468.     SHORT                 i;
  1469.  
  1470.     Forbid();
  1471.  
  1472.     DevInfo = (struct DeviceNode *)BADDR(((struct DosInfo *)BADDR(RootNode -> rn_Info)) -> di_DevInfo);
  1473.  
  1474.     while(DevInfo)
  1475.     {
  1476.         if(DevInfo -> dn_Type == DLT_DEVICE && DevInfo -> dn_Task)
  1477.         {
  1478.             Pointer = (char *)BADDR(DevInfo -> dn_Name);
  1479.  
  1480.             for(i = 0 ; i < Pointer[0] ; i++)
  1481.                 Name[i] = Pointer[i + 1];
  1482.  
  1483.             Name[Pointer[0]    ] = ':';
  1484.             Name[Pointer[0] + 1] = 0;
  1485.  
  1486.             if(!Strcmp(Name,DevName))
  1487.             {
  1488.                 Permit();
  1489.                 return(TRUE);
  1490.             }
  1491.         }
  1492.  
  1493.         DevInfo = (struct DeviceNode *)BADDR(DevInfo -> dn_Next);
  1494.     }
  1495.  
  1496.     Permit();
  1497.  
  1498.     return(FALSE);
  1499. }
  1500.  
  1501.     /* EraseGadget(RPort,Gadget,Colour):
  1502.      *
  1503.      *    Erase the imagery of a gadget.
  1504.      */
  1505.  
  1506. VOID
  1507. EraseGadget(RPort,Gadget,Colour)
  1508. struct RastPort *RPort;
  1509. struct Gadget *Gadget;
  1510. LONG Colour;
  1511. {
  1512.     SetAPen(RPort,Colour);
  1513.  
  1514.     SetDrMd(RPort,JAM2);
  1515.  
  1516.     RectFill(RPort,Gadget -> LeftEdge,Gadget -> TopEdge,Gadget -> LeftEdge + Gadget -> Width - 1,Gadget -> TopEdge + Gadget -> Height - 1);
  1517.  
  1518.     SetAPen(RPort,1);
  1519. }
  1520.  
  1521.     /* GetChangeCount(Drive):
  1522.      *
  1523.      *    Get the disk change count for a drive (the ETD_... commands
  1524.      *    need it.
  1525.      */
  1526.  
  1527. LONG
  1528. GetChangeCount(Drive)
  1529. LONG Drive;
  1530. {
  1531.     LONG Count = -1;
  1532.  
  1533.     if(DiskPort = (struct MsgPort *)CreatePort(NULL,0))
  1534.     {
  1535.         if(DiskRequest = (struct IOExtTD *)CreateExtIO(DiskPort,sizeof(struct IOExtTD)))
  1536.         {
  1537.             if(!OpenDevice("trackdisk.device",Drive,DiskRequest,0))
  1538.             {
  1539.                 DiskRequest -> iotd_Req . io_Command = TD_CHANGENUM;
  1540.                 DoIO(DiskRequest);
  1541.  
  1542.                 Count = DiskRequest -> iotd_Req . io_Actual;
  1543.  
  1544.                 CloseDevice(DiskRequest);
  1545.             }
  1546.  
  1547.             DeleteExtIO(DiskRequest);
  1548.         }
  1549.  
  1550.         DeletePort(DiskPort);
  1551.     }
  1552.  
  1553.     DiskRequest = NULL;
  1554.     DiskPort = NULL;
  1555.  
  1556.     return(Count);
  1557. }
  1558.  
  1559.     /* Stub, don't need this one. */
  1560.  
  1561. LONG CXBRK() { return(0); }
  1562.  
  1563.     /* main(argc,argv):
  1564.      *
  1565.      *    The entry point to this program.
  1566.      */
  1567.  
  1568. VOID __stdargs
  1569. main(argc,argv)
  1570. LONG argc;
  1571. char **argv;
  1572. {
  1573.     struct Process    *ThatsMe = (struct Process *)SysBase -> ThisTask;
  1574.     LONG         i,Waiting = FALSE,Who;
  1575.     ULONG         Secs1,Secs2,Micros;
  1576.     APTR         OldPtr;
  1577.  
  1578.         /* Started from Workbench? */
  1579.  
  1580.     if(ThatsMe -> pr_CLI)
  1581.         goto CallOn;
  1582.  
  1583.         /* Open the req.library. */
  1584.  
  1585.     if(!(ReqBase = (struct Library *)OpenLibrary("req.library",0)))
  1586.         exit(RETURN_FAIL);
  1587.  
  1588.         /* Don't forget the standard font. */
  1589.  
  1590.     if(!(TextFont = (struct TextFont *)OpenFont(&TxtAttr)))
  1591.     {
  1592.         CloseLibrary(ReqBase);
  1593.         exit(RETURN_FAIL);
  1594.     }
  1595.  
  1596.         /* All device gadgets are vacant. */
  1597.  
  1598.     for(i = 0 ; i < 5 ; i++)
  1599.         Legal[i] = TRUE;
  1600.  
  1601.         /* Try to open it, if it doesn't open don't squeak about it. */
  1602.  
  1603.     IconBase = OpenLibrary("icon.library",0);
  1604.  
  1605.     SPrintf(WindowName,"CompDisk 1.%ld  ",PRGVERSION);
  1606.  
  1607.         /* Now try to find if there's a legal drive for each
  1608.          * gadget.
  1609.          */
  1610.  
  1611.     if(!FindDevice("RAD:"))
  1612.     {
  1613.         BoxGad[0] . Flags |= GADGDISABLED;
  1614.         Legal[0] = FALSE;
  1615.     }
  1616.  
  1617.     if(!FindDevice("DF3:"))
  1618.     {
  1619.         BoxGad[1] . Flags |= GADGDISABLED;
  1620.         Legal[1] = FALSE;
  1621.     }
  1622.  
  1623.     if(!FindDevice("DF2:"))
  1624.     {
  1625.         BoxGad[2] . Flags |= GADGDISABLED;
  1626.         Legal[2] = FALSE;
  1627.     }
  1628.  
  1629.     if(!FindDevice("DF1:"))
  1630.     {
  1631.         BoxGad[3] . Flags |= GADGDISABLED;
  1632.         Legal[3] = FALSE;
  1633.     }
  1634.  
  1635.     if(!FindDevice("DF0:"))
  1636.     {
  1637.         BoxGad[4] . Flags |= GADGDISABLED;
  1638.         Legal[4] = FALSE;
  1639.     }
  1640.  
  1641.         /* So we have valid destination path. */
  1642.  
  1643.     PathName(ThatsMe -> pr_CurrentDir,StrInfStr,DSIZE * 3);
  1644.  
  1645.         /* Remember old AmigaDOS requester ptr. */
  1646.  
  1647.     OldPtr = ThatsMe -> pr_WindowPtr;
  1648.  
  1649.     for(i = 0 ; i < 4 ; i++)
  1650.         ChangeCount[i] = GetChangeCount(i);
  1651.  
  1652.         /* Centre the window under the mouse. */
  1653.  
  1654.     Center(&NewWindow,NewWindow . Width / 2,NewWindow . Height / 2);
  1655.  
  1656.         /* Open the window. */
  1657.  
  1658.     if(Window = OpenWindow(&NewWindow))
  1659.     {
  1660.         LONG     TempLock,TempVal;
  1661.         UBYTE    *RemText,*RemMain;
  1662.  
  1663.         ThatsMe -> pr_WindowPtr = (APTR)Window;
  1664.  
  1665.         RPort = Window -> RPort;
  1666.  
  1667.         SetFont(RPort,TextFont);
  1668.  
  1669.         SetAPen(RPort,1);
  1670.  
  1671.         FOREVER
  1672.         {
  1673.             Move(RPort,100,76);
  1674.             Punch("Track");
  1675.  
  1676.             Move(RPort,151,76);
  1677.             Punch("00/00");
  1678.  
  1679.             Move(RPort,100,85);
  1680.             Punch("Idle ");
  1681.  
  1682.             Move(RPort,151,85);
  1683.             Punch("    0");
  1684.  
  1685.             WaitPort(Window -> UserPort);
  1686.  
  1687.             if(Massage = (struct IntuiMessage *)GetMsg(Window -> UserPort))
  1688.             {
  1689.                 Class    = Massage -> Class;
  1690.                 Code    = Massage -> Code;
  1691.                 Gadget    = (struct Gadget *)Massage -> IAddress;
  1692.  
  1693.                 ReplyMsg((struct Message *)Massage);
  1694.  
  1695.                     /* Close the window? */
  1696.  
  1697.                 if(Class == CLOSEWINDOW)
  1698.                     break;
  1699.  
  1700.                 if(Class == GADGETUP)
  1701.                 {
  1702.                         /* User entered a path name. */
  1703.  
  1704.                     if(Gadget -> GadgetID == 5)
  1705.                     {
  1706.                         if(!strlen(StrInfStr))
  1707.                         {
  1708. Build:                            PathName(ThatsMe -> pr_CurrentDir,StrInfStr,DSIZE * 3);
  1709.                             RefreshGadgets(&BoxGad[0],Window,NULL);
  1710.                         }
  1711.  
  1712.                         if(!(TempLock = Lock(StrInfStr,ACCESS_READ)))
  1713.                         {
  1714.                             DisplayBeep(Window -> WScreen);
  1715.  
  1716.                             SimpleRequest("Can't get a lock on directory\n\"%s\"!",StrInfStr);
  1717.                             goto Build;
  1718.                         }
  1719.                         else
  1720.                             UnLock(TempLock);
  1721.  
  1722.                         continue;
  1723.                     }
  1724.  
  1725.                     if(Waiting)
  1726.                         goto Finish;
  1727.  
  1728.                         /* Select/deselect a drive gadget. */
  1729.  
  1730.                     TempVal = Gadget -> GadgetID;
  1731.  
  1732.                     RemText = BoxIntTxt[TempVal] . IText;
  1733.  
  1734.                     BoxIntTxt[TempVal] . IText = (UBYTE *)"Stop!";
  1735.  
  1736.                     EraseGadget(RPort,&BoxGad[TempVal],3);
  1737.  
  1738.                     for(i = 0 ; i < 5 ; i++)
  1739.                         if(i != TempVal && Legal[i])
  1740.                             OffGadget(&BoxGad[i],Window,NULL);
  1741.  
  1742.                     RefreshGadgets(&BoxGad[0],Window,NULL);
  1743.  
  1744.                     RemMain = BoxIntTxt[5] . IText;
  1745.  
  1746.                     if(TempVal == 0)
  1747.                         goto DoIt;
  1748.  
  1749.                     BoxIntTxt[5] . IText = (UBYTE *)"Insert Disk";
  1750.  
  1751.                     RefreshGadgets(&BoxGad[0],Window,NULL);
  1752.  
  1753.                     DriveWanted = TempVal;
  1754.  
  1755.                     Waiting = TRUE;
  1756.                     continue;
  1757.  
  1758. Finish:                    for(i = 0 ; i < 5 ; i++)
  1759.                     {
  1760.                         if(i != TempVal && Legal[i])
  1761.                         {
  1762.                             EraseGadget(RPort,&BoxGad[i],0);
  1763.                             OnGadget(&BoxGad[i],Window,NULL);
  1764.                         }
  1765.                     }
  1766.  
  1767.                     BoxIntTxt[TempVal] . IText = RemText;
  1768.  
  1769.                     BoxIntTxt[5] . IText = RemMain;
  1770.  
  1771.                     EraseGadget(RPort,&BoxGad[TempVal],0);
  1772.  
  1773.                     RefreshGadgets(&BoxGad[0],Window,NULL);
  1774.  
  1775.                     Waiting = FALSE;
  1776.  
  1777.                     DriveWanted = -1;
  1778.                 }
  1779.  
  1780.                     /* Inserted a disk. */
  1781.         
  1782.                 if(Class == DISKINSERTED)
  1783.                 {
  1784.                     if(DriveWanted == -1)
  1785.                         continue;
  1786.  
  1787.                     Who = -1;
  1788.  
  1789.                     for(i = 0 ; i < 4 ; i++)
  1790.                     {
  1791.                         if(ChangeCount[i] != GetChangeCount(i) && i == (4 - DriveWanted))
  1792.                             Who = i;
  1793.  
  1794.                         ChangeCount[i] = GetChangeCount(i);
  1795.                     }
  1796.  
  1797.                     if(Who == -1)
  1798.                         continue;
  1799.  
  1800.                         /* Is it the drive we want? */
  1801.  
  1802. DoIt:                    for(i = strlen(StrInfStr) - 1 ; i >= 0 ; i--)
  1803.                     {
  1804.                         if(StrInfStr[i] != ':')
  1805.                             StrInfStr[i] = 0;
  1806.                         else
  1807.                             break;
  1808.                     }
  1809.  
  1810.                     if(TempLock = Lock(Drives[DriveWanted],ACCESS_READ))
  1811.                     {
  1812.                         struct FileInfoBlock *FileInfo = (struct FileInfoBlock *)AllocMem(sizeof(struct FileInfoBlock),MEMF_PUBLIC);
  1813.  
  1814.                         if(Examine(TempLock,FileInfo))
  1815.                         {
  1816.                             TackOn(StrInfStr,FileInfo -> fib_FileName);
  1817.                             strcat(StrInfStr,".CMP");
  1818.                             RefreshGadgets(&BoxGad[0],Window,NULL);
  1819.                         }
  1820.                         else
  1821.                         {
  1822.                             TackOn(StrInfStr,"NoName");
  1823.                             strcat(StrInfStr,".CMP");
  1824.                             RefreshGadgets(&BoxGad[0],Window,NULL);
  1825.                         }
  1826.  
  1827.                         UnLock(TempLock);
  1828.                         FreeMem(FileInfo,sizeof(struct FileInfoBlock));
  1829.                     }
  1830.                     else
  1831.                     {
  1832.                         DisplayBeep(NULL);
  1833.                         continue;
  1834.                     }
  1835.  
  1836.                     BoxIntTxt[5] . IText = (UBYTE *)"   Working ";
  1837.  
  1838.                     RefreshGadgets(&BoxGad[0],Window,NULL);
  1839.  
  1840.                     SetDrMd(RPort,JAM2);
  1841.  
  1842.                     RemoveGadget(Window,&BoxGad[5]);
  1843.  
  1844.                     SetWait(Window);
  1845.  
  1846.                         /* Create the dump file. */
  1847.  
  1848.                     if(!ReadDump(StrInfStr,Drives[DriveWanted]))
  1849.                     {
  1850.                         DeleteFile(StrInfStr);
  1851.                         DisplayBeep(NULL);
  1852.                     }
  1853.                     else
  1854.                     {
  1855.                             /* If possible, create the icon. */
  1856.  
  1857.                         if(IconBase)
  1858.                             SaveProjectIcon(StrInfStr);
  1859.  
  1860.                             /* Ring the bell. */
  1861.  
  1862.                         Announce();
  1863.  
  1864.                         SimpleRequest("Resulting dump file \"%s\" is %ld\nbytes long.",StrInfStr,GetFileSize(StrInfStr));
  1865.                     }
  1866.  
  1867.                     for(i = strlen(StrInfStr) - 1 ; i >= 0 ; i--)
  1868.                     {
  1869.                         if(StrInfStr[i] != ':')
  1870.                             StrInfStr[i] = 0;
  1871.                         else
  1872.                             break;
  1873.                     }
  1874.  
  1875.                     AddGadget(Window,&BoxGad[5],5);
  1876.  
  1877.                     BoxIntTxt[5] . IText = (UBYTE *)"Insert Disk";
  1878.  
  1879.                     RefreshGadgets(&BoxGad[0],Window,NULL);
  1880.  
  1881.                         /* Finished, wait for next disk. */
  1882.  
  1883.                     ClearPointer(Window);
  1884.                 }
  1885.             }
  1886.         }
  1887.  
  1888.         CloseWindow(Window);
  1889.     }
  1890.     else
  1891.         SimpleRequest("Couldn't open Window!");
  1892.  
  1893.         /* Restore the old ptr. */
  1894.  
  1895.     ThatsMe -> pr_WindowPtr = OldPtr;
  1896.  
  1897.         /* Close the rest. */
  1898.  
  1899.     if(IconBase)
  1900.         CloseLibrary(IconBase);
  1901.  
  1902.     CloseFont(TextFont);
  1903.  
  1904.     CloseLibrary(ReqBase);
  1905.  
  1906.     exit(RETURN_OK);
  1907.  
  1908.         /* This follows the CLI interface. */
  1909.  
  1910. CallOn:    if(!argv[ARG_FILE])
  1911.     {
  1912.         Puts("\33[1mCompDisk:\33[0m Output/source filename required.");
  1913.         Puts(CLI_Help);
  1914.         exit(RETURN_WARN);
  1915.     }
  1916.  
  1917.         /* Drive name given? */
  1918.  
  1919.     if(!argv[ARG_DRIVE])
  1920.     {
  1921.         Puts("\33[1mCompDisk:\33[0m Output/source drive name required.");
  1922.         Puts(CLI_Help);
  1923.         exit(RETURN_WARN);
  1924.     }
  1925.  
  1926.     if(argv[ARG_NOCLEAR])
  1927.     {
  1928.         ClearBlocks = FALSE;
  1929.         Puts("\33[1m\33[33mWarning:\33[31m\33[0m unused blocks are \33[4mnot\33[0m cleared!");
  1930.     }
  1931.  
  1932.     Puts("");
  1933.  
  1934.         /* So we have valid time counter. */
  1935.  
  1936.     CurrentTime(&Secs1,&Micros);
  1937.  
  1938.         /* Do the compression. */
  1939.  
  1940.     if(!ReadDump(argv[ARG_FILE],argv[ARG_DRIVE]))
  1941.     {
  1942.         DeleteFile(argv[ARG_FILE]);
  1943.         Printf("\nDestination file \"%s\" removed.\n",argv[ARG_FILE]);
  1944.     }
  1945.     else
  1946.         Printf("\2331AResulting dump file \"%s\" is %ld bytes long.\233K\n",argv[ARG_FILE],GetFileSize(argv[ARG_FILE]));
  1947.  
  1948.         /* Compare the difference. */
  1949.  
  1950.     CurrentTime(&Secs2,&Micros);
  1951.  
  1952.         /* Show the statistics. */
  1953.  
  1954.     Printf("Elapsed time = %ld.%02ld minutes\n",(Secs2 - Secs1) / 60,(Secs2 - Secs1) % 60);
  1955.  
  1956.     exit(RETURN_OK);
  1957. }
  1958.