开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
msdsys.c
资源名称：DOS系统的源代码.rar　[点击查看]
上传用户：xiaoan1112
上传日期：2013-04-11
资源大小：19621k
文件大小：77k
源码类别：

操作系统开发

开发平台：

Visual C++

msdsys.c：源码内容
  1. /*********************************************************************
  2.  * Microsoft Diagnostics Version 2.0
  3.  *
  4.  * A diagnostic utility to detect as much useful information about a
  5.  *   customer's computer system as is possible.
  6.  *
  7.  * Microsoft Diagnostics:  We detect the World.
  8.  *
  9.  * MSDSYS.C - Source file for system related code (ie file I/O).
  10.  ********************************************************************/
  13. /* Include Files */
  15. #include "msd.h"
  18. /********************************************************************
  19.  * OpenFile - Opens a file and provides appropriate error handling.
  20.  *
  21.  * pszFilename - Name of file
  22.  * pszMode     - Mode to open the file.
  23.  * fShowError  - Displays errors when TRUE.
  24.  *
  25.  * Returns: FILE handle, or NULL if an error condition occured.
  26.  ********************************************************************/
  28. FILE * OpenFile (PSZ pszFilename, PSZ pszMode, BOOL fShowError)
  29. {
  30.   FILE *fp;           /* Local storage for the file pointer */
  32.   /* Open the file */
  34.   fp = fopen (pszFilename, pszMode);
  36.   /* Give appropriate error message, if necessary */
  38.   if (fShowError && (fp == NULL || fCriticalError))
  39.     {
  40.       fCriticalError = FALSE;
  42.       ShowError (ERR_OK_BUTTON, pszErrorOpening, pszFilename, 
  43.                  _strerror (NULL));
  45.       return (NULL);
  46.     }
  48.   /* If all went well, return the file pointer to the calling routine */
  50.   return (fp);
  51. }
  54. /********************************************************************
  55.  * CloseFile - Closes a file and provides appropriate error handling.
  56.  *
  57.  * fp - File handle to close
  58.  *
  59.  * Returns: TRUE if an error occured.
  60.  ********************************************************************/
  62. BOOL CloseFile (FILE *fp)
  63. {
  64.   WORD wReturnValue;  /* Return value from fclose */
  67.   /* Close the file */
  68.   wReturnValue = fclose (fp);
  70.   /* Give appropriate error message, if necessary */
  71.   if (wReturnValue == EOF)
  72.     {
  73.       fCriticalError = FALSE;
  75.       ShowError (ERR_OK_BUTTON, pszErrorClosing, NULL, _strerror (NULL));
  77.       return (TRUE);
  78.     }
  80.   return (FALSE);
  81. }
  84. /**********************************************************************
  85.  * CreateTempFile - Uses a DOS 3+ call to create a unique file
  86.  *
  87.  * pszPathname - Path to where the temp file needs to go.
  88.  *
  89.  * Returns: Error number:
  90.  *          03 - Path not found.
  91.  *          04 - No more handles.
  92.  *          05 - Access denied.
  93.  **********************************************************************/
  95. WORD CreateTempFile (PSZ pszPathname)
  96. {
  97.   union REGS inregs, outregs;   /* Register values for int86x */
  98.   struct SREGS sregs;           /* Segment register values */
  99.   CHAR FAR * fpszPathname = (CHAR FAR *) pszPathname;
  101.   inregs.h.ah = 0x5A;
  102.   inregs.x.cx = 0;
  103.   sregs.ds    = (WORD) FP_SEG (fpszPathname);
  104.   inregs.x.dx = (WORD) FP_OFF (fpszPathname);
  106.   int86x (0x21, &inregs, &outregs, &sregs);
  108.   if (outregs.x.cflag)
  109.     return (outregs.x.ax);
  110.   else
  111.     return (0);
  112. }
  115. /**********************************************************************
  116.  * DeleteFile - Deletes file specified by pszFilename
  117.  *
  118.  * pszFilename - File to delete
  119.  *
  120.  * Returns: Error number:
  121.  *          02 - File not found.
  122.  *          03 - Path not found.
  123.  *          05 - Access denied.
  124.  **********************************************************************/
  126. WORD DeleteFile (PSZ pszPathname)
  127. {
  128.   union REGS inregs, outregs;   /* Register values for intdos */
  129.   struct SREGS sregs;           /* Segment register values */
  130.   CHAR FAR * fpszPathname = (CHAR FAR *) pszPathname;
  132.   inregs.h.ah = 0x41;
  133.   sregs.ds    = (WORD) FP_SEG (fpszPathname);
  134.   inregs.x.dx = (WORD) FP_OFF (fpszPathname);
  136.   int86x (0x21, &inregs, &outregs, &sregs);
  138.   if (outregs.x.cflag)
  139.     return (outregs.x.ax);
  140.   else
  141.     return (0);
  142. }
  145. /**********************************************************************
  146.  * RenameFile - Renames a file.
  147.  *
  148.  * pszPathname1 - File to rename.
  149.  * pszPathname2 - New filename.
  150.  *
  151.  * Returns: Error number:
  152.  *          02 - File not found.
  153.  *          03 - Path not found.
  154.  *          05 - Access denied.
  155.  *          17 - (11H) Not the same device.
  156.  **********************************************************************/
  158. WORD RenameFile (PSZ pszPathname1, PSZ pszPathname2)
  159. {
  160.   union REGS inregs, outregs;   /* Register values for intdos */
  161.   struct SREGS sregs;           /* Segment register values */
  162.   CHAR FAR * fpszPathname1 = (CHAR FAR *) pszPathname1;
  163.   CHAR FAR * fpszPathname2 = (CHAR FAR *) pszPathname2;
  165.   inregs.h.ah = 0x56;
  166.   sregs.ds    = (WORD) FP_SEG (fpszPathname1);
  167.   inregs.x.dx = (WORD) FP_OFF (fpszPathname1);
  168.   sregs.es    = (WORD) FP_SEG (fpszPathname2);
  169.   inregs.x.di = (WORD) FP_OFF (fpszPathname2);
  171.   int86x (0x21, &inregs, &outregs, &sregs);
  173.   if (outregs.x.cflag)
  174.     return (outregs.x.ax);
  175.   else
  176.     return (0);
  177. }
  179. WORD wNmbrFound = 0;
  181. /*********************************************************************
  182.  * FindFile - Finds all of the pszFilename files on the system.
  183.  *
  184.  * pszFilename   - Filename to find.
  185.  *
  186.  * pszPathname   - Path to start searching from (NULL if it's to be
  187.  *                 ignored).
  188.  *
  189.  * fSearchFlags  - SEARCH_FLOPPIES          Search floppies.
  190.  *                 SEARCH_LOCAL_DRIVES      Search local hard disks.
  191.  *                 SEARCH_NET_DRIVES        Search net drives (and
  192.  *                                          all other drives).
  193.  *                 SEARCH_ROOT              Search the root directory.
  194.  *                 RECURSE_INTO_SUB_DIRS    Search recursively into
  195.  *                                          subdirectories.
  196.  *
  197.  *                 Only one of the following should be specified at
  198.  *                   one time:
  199.  *                 SEARCH_LANMAN_ROOT       Searches in the LANMAN
  200.  *                                          root directory.
  201.  *                 SEARCH_WINDIR            Uses the "windir="
  202.  *                                          environment variable.
  203.  *                 SEARCH_BOOT_DRIVE        Search just the boot drive.
  204.  *
  205.  * chDriveLetter - If fSearchFlags does not specify the drive type(s)
  206.  *                 to search, this contains the drive letter to
  207.  *                 search.  ('' to search current drive).
  208.  *
  209.  * Returns:  Pointer to an array of strings to pszFilename files, the
  210.  *           last pointer is a NULL pointer.  If pszFilename could
  211.  *           not be found, or an error occured, the first pointer is a
  212.  *           NULL.
  213.  *********************************************************************/
  215. FILE_INFO FAR *FindFile (PSZ  pszFilename,
  216.                          PSZ  pszPathname,
  217.                          BOOL fSearchFlags,
  218.                          CHAR chDriveLetter)
  219. {
  220.   CHAR chCurrentPath[_MAX_PATH + 1];  /* Stores current drive & directory  */
  221.   WORD wCurrentDrive;                 /* Stores the current drive number   */
  222.   WORD i;                             /* Looping variable                  */
  223.   DISK_STRUCT *pDisk = NULL;          /* Pointer to disk drive info        */
  224.                                       /*   structure                       */
  225.   OS_VERSION_STRUCT *pOsVer = NULL;   /* Pointer to DOS info structure     */
  226.   BOOL fReturnValue = FALSE;          /* Stores the return value from      */
  227.                                       /*   fuctions                        */
  228.   FILE_INFO FAR *pFileInfo = NULL;    /* Pointer to file info linked list  */
  229.   FILE_INFO FAR *pfi = NULL;          /* Another pointer to file info list */
  230.                                       /*   (this one is changed by the     */
  231.                                       /*   called routines).               */
  234.   /* Save the current drive and directory */
  235.   wCurrentDrive = _getdrive();
  236.   _getdcwd (wCurrentDrive, chCurrentPath, _MAX_PATH);
  239.   /* Allocate enough room for the find file info */
  240.   pFileInfo = _fmalloc (sizeof (FILE_INFO));
  241.   if (pFileInfo == NULL)
  242.     {
  243.       OutOfMemory();
  244.       return (NULL);
  245.     }
  246.   pfi = pFileInfo;
  249.   /* Set the first pointer to null, to show that */
  250.   /*   this is the last on the list.             */
  251.   pFileInfo->fpNextFileInfo = NULL;
  254.   /* Get the disk and operating system structures */
  255.   fReturnValue = GetFindFileInfo (&pDisk, &pOsVer, fSearchFlags);
  256.   if (fReturnValue)
  257.     {
  258.       FreeFileInfo (pFileInfo);
  259.       return (NULL);
  260.     }
  263.   /* Zero out the counter for files found */
  264.   wNmbrFound = 0;
  266.   /* Change to the appropriate drive and directory if necessary */
  267.   if (pszPathname != NULL)
  268.     {
  269.       /* Check to see if a drive was passed to us */
  270.       if (pszPathname[1] == ':')
  271.         {
  272.           WORD wDrive = toupper (pszPathname[0]) - 'A' + 1;
  273.           if (_chdrive (wDrive))
  274.             {
  275.               MessageBox ("Drive does not exist", pszPathname, NULL, MB_OK | 0x8000);
  276.               return (NULL);
  277.             }
  278.           if (chdir (&pszPathname[2]))
  279.             {
  280.               MessageBox (pszPathNotThere, pszPathname, NULL, MB_OK | 0x8000);
  281.               return (NULL);
  282.             }
  283.         }
  284.       else
  285.         if (chdir (pszPathname))
  286.           {
  287.             MessageBox (pszPathNotThere, pszPathname, NULL, MB_OK | 0x8000);
  288.             return (NULL);
  289.           }
  290.     }
  293.   /* Boot drive search */
  294.   if (fSearchFlags & SEARCH_BOOT_DRIVE)
  295.     {
  296.       FindOnBootDrive (&pfi,
  297.                        pDisk,
  298.                        pOsVer,
  299.                        pszFilename,
  300.                        fSearchFlags);
  301.     }
  302.   else if (fSearchFlags & SEARCH_WINDIR)
  303.     {
  304.       /* Find the "windir=" environment variable */
  305.       for (i = 0;
  306.            environ[i][0] != '' && memcmp ("windir=", environ[i], 7) != 0;
  307.            ++i)
  308.         ;
  310.       /* If found, put the fully qualified path into chWinDir */
  311.       if (environ[i][0] == 'w')
  312.         {
  313.           /* Change to the drive and directory of the file */
  314.           chDriveLetter = environ[i][7];
  315.           chdir (&environ[i][9]);
  317.           /* Find the file */
  318.           FindFileOnDrive (&pfi,
  319.                            pszFilename,
  320.                            fSearchFlags,
  321.                            chDriveLetter);
  322.         }
  323.       else
  324.         {
  325.           /* Free up pFileInfo */
  326.           _ffree (pFileInfo);
  328.           /* Set the flags for finding the windows file the hard way */
  329.           fSearchFlags = SEARCH_LOCAL_DRIVES   |
  330.                          SEARCH_ROOT           |
  331.                          RECURSE_INTO_SUB_DIRS;
  333.           /* Find the file */
  334.           pFileInfo = FindFile (pszFilename, pszPathname,
  335.                                 fSearchFlags, chDriveLetter);
  336.         }
  337.     }
  338.   else if (fSearchFlags & SEARCH_LANMAN_ROOT)
  339.     {
  340.       unsigned short int err=0, ta=0;
  341.       struct wksta_info_0 *wksta0;
  342.       char wkstabuf[BUFSIZ];
  343.       CHAR chBuffer[_MAX_PATH + 1];
  345.       /* Get the LANMAN root */
  346.       err = NetWkstaGetInfo (NULL, 0, wkstabuf, BUFSIZ, &ta);
  347.       if (err == 0)
  348.         {
  349.           wksta0 = (struct wksta_info_0 *) wkstabuf;
  350.           _fmemcpy (chBuffer, wksta0->wki0_root, _MAX_PATH);
  352.           /* Change to the drive and directory of the file */
  353.           chDriveLetter = chBuffer[0];
  354.           chdir (&chBuffer[2]);
  356.           /* Find the file */
  357.           FindFileOnDrive (&pfi,
  358.                            pszFilename,
  359.                            fSearchFlags,
  360.                            chDriveLetter);
  361.         }
  362.       else
  363.         {
  364.           /* Free up pFileInfo */
  365.           _ffree (pFileInfo);
  367.           /* Set the flags for finding the LANMAN file the hard way */
  368.           fSearchFlags = SEARCH_LOCAL_DRIVES   |
  369.                          SEARCH_ROOT           |
  370.                          RECURSE_INTO_SUB_DIRS;
  372.           /* Find the file */
  373.           pFileInfo = FindFile (pszFilename, pszPathname,
  374.                                 fSearchFlags, chDriveLetter);
  375.         }
  376.     }
  377.   else if ((fSearchFlags & (SEARCH_FLOPPIES     |
  378.                             SEARCH_LOCAL_DRIVES |
  379.                             SEARCH_NET_DRIVES   |
  380.                             SEARCH_BOOT_DRIVE)) == 0)
  381.     {
  382.       /* Single drive search */
  383.       FindFileOnDrive (&pfi,
  384.                        pszFilename,
  385.                        fSearchFlags,
  386.                        chDriveLetter);
  387.     }
  388.   else
  389.     {
  390.       /* Search 'em all */
  391.       for (i = 0; i < pDisk->wNmbrDrives; ++i)
  392.         {
  393.           /* Floppy Search */
  394.           if ((fSearchFlags & SEARCH_FLOPPIES) &&
  395.               (pDisk->asdi[i].wDriveType == DISK_FLOPPY_DRIVE          ||
  396.                pDisk->asdi[i].wDriveType == DISK_525_360K              ||
  397.                pDisk->asdi[i].wDriveType == DISK_525_12M               ||
  398.                pDisk->asdi[i].wDriveType == DISK_35_720K               ||
  399.                pDisk->asdi[i].wDriveType == DISK_SINGLE_DENSITY_8_INCH ||
  400.                pDisk->asdi[i].wDriveType == DISK_DOUBLE_DENSITY_8_INCH ||
  401.                pDisk->asdi[i].wDriveType == DISK_35_144M               ||
  402.                pDisk->asdi[i].wDriveType == DISK_OPTICAL_DISK          ||
  403.                pDisk->asdi[i].wDriveType == DISK_35_288M))
  404.             {
  405.               FindFileOnDrive (&pfi,
  406.                                pszFilename,
  407.                                fSearchFlags,
  408.                                pDisk->asdi[i].chDriveLetter);
  409.             }
  411.           /* Local drive search */
  412.           if ((fSearchFlags & SEARCH_LOCAL_DRIVES) &&
  413.               (pDisk->asdi[i].wDriveType == DISK_FIXED_DISK   ||
  414.                pDisk->asdi[i].wDriveType == DISK_RAM_DISK     ||
  415.                pDisk->asdi[i].wDriveType == DISK_CD_ROM_DRIVE ||
  416.                pDisk->asdi[i].wDriveType == DISK_SUBST_DRIVE  ||
  417.                pDisk->asdi[i].wDriveType == DISK_ASSIGN_DRIVE))
  418.             {
  419.               FindFileOnDrive (&pfi,
  420.                                pszFilename,
  421.                                fSearchFlags,
  422.                                pDisk->asdi[i].chDriveLetter);
  423.             }
  425.           /* Remote/Net drive search */
  426.           if ((fSearchFlags & SEARCH_NET_DRIVES) &&
  427.               pDisk->asdi[i].wDriveType == DISK_REMOTE_DRIVE)
  428.             {
  429.               FindFileOnDrive (&pfi,
  430.                                pszFilename,
  431.                                fSearchFlags,
  432.                                pDisk->asdi[i].chDriveLetter);
  433.             }
  434.         }
  435.     }
  437.   /* Restore the current drive and directory */
  438.   _chdrive (wCurrentDrive);
  439.   chdir (chCurrentPath);
  442.   /* Free up the disk and operating system info */
  443.   free (pDisk);
  444.   free (pOsVer);
  446.   return (pFileInfo);
  447. }
  450. /*********************************************************************
  451.  * FindOnBootDrive - Finds a particular file on the boot drive.  If
  452.  *                   the operating system does not have the ability
  453.  *                   to return the boot drive, it will check the first
  454.  *                   hard disk, the first floppy, then all other
  455.  *                   drives on the system (based on the flags set in
  456.  *                   fSearchFlags, of course).
  457.  *
  458.  * ppFileInfo   - Pointer to file info structure's pointer.
  459.  * pszFilename  - Filename to search for.
  460.  * fSearchFlags - Flags to control the search.
  461.  *
  462.  * Returns:  TRUE if an error occured.
  463.  *********************************************************************/
  465. BOOL FindOnBootDrive (FILE_INFO FAR * FAR *ppFileInfo,
  466.                       DISK_STRUCT         *pDisk,
  467.                       OS_VERSION_STRUCT   *pOsVer,
  468.                       PSZ                 pszFilename,
  469.                       BOOL                fSearchFlags)
  470. {
  471.   BOOL fSkipFirstFloppy   = TRUE;  /* Allows us to skip drives */
  472.   BOOL fSkipFirstHardDisk = TRUE;  /*   we already checked     */
  475.   /* Check to see if DOS can tell us it's boot drive */
  476.   if (pOsVer->wDosMajor >= 4)
  477.     {
  478.       /* Set the flags for the appropriate search */
  479.       fSearchFlags = fSearchFlags | SEARCH_ROOT;
  481.       /* Find it */
  482.       FindFileOnDrive (ppFileInfo,
  483.                        pszFilename,
  484.                        fSearchFlags,
  485.                        pOsVer->chDosBootDrive);
  486.     }
  487.   else
  488.     {
  489.       WORD i;   /* Looping variable */
  491.       /* We have to hunt for a suitable boot drive */
  493.       /* Set the flags for the appropriate search */
  494.       fSearchFlags = fSearchFlags          |
  495.                      SEARCH_FLOPPIES       |
  496.                      SEARCH_LOCAL_DRIVES   |
  497.                      SEARCH_ROOT;
  499.       /* Check the first hard disk */
  500.       if (fSearchFlags & SEARCH_LOCAL_DRIVES)
  501.         {
  502.           for (i = 0; i < pDisk->wNmbrDrives; ++i)
  503.             {
  504.               if (pDisk->asdi[i].wDriveType == DISK_FIXED_DISK   ||
  505.                   pDisk->asdi[i].wDriveType == DISK_RAM_DISK     ||
  506.                   pDisk->asdi[i].wDriveType == DISK_CD_ROM_DRIVE ||
  507.                   pDisk->asdi[i].wDriveType == DISK_SUBST_DRIVE  ||
  508.                   pDisk->asdi[i].wDriveType == DISK_ASSIGN_DRIVE)
  509.                 {
  510.                   FindFileOnDrive (ppFileInfo,
  511.                                    pszFilename,
  512.                                    fSearchFlags,
  513.                                    pDisk->asdi[i].chDriveLetter);
  514.                   break;
  515.                 }
  516.             }
  517.         }
  520.       /* Check the first floppy */
  521.       if (fSearchFlags & SEARCH_FLOPPIES)
  522.         {
  523.           for (i = 0; i < pDisk->wNmbrDrives; ++i)
  524.             {
  525.               if (pDisk->asdi[i].wDriveType == DISK_FLOPPY_DRIVE          ||
  526.                   pDisk->asdi[i].wDriveType == DISK_525_360K              ||
  527.                   pDisk->asdi[i].wDriveType == DISK_525_12M               ||
  528.                   pDisk->asdi[i].wDriveType == DISK_35_720K               ||
  529.                   pDisk->asdi[i].wDriveType == DISK_SINGLE_DENSITY_8_INCH ||
  530.                   pDisk->asdi[i].wDriveType == DISK_DOUBLE_DENSITY_8_INCH ||
  531.                   pDisk->asdi[i].wDriveType == DISK_35_144M               ||
  532.                   pDisk->asdi[i].wDriveType == DISK_OPTICAL_DISK          ||
  533.                   pDisk->asdi[i].wDriveType == DISK_35_288M)
  534.                 {
  535.                   FindFileOnDrive (ppFileInfo,
  536.                                    pszFilename,
  537.                                    fSearchFlags,
  538.                                    pDisk->asdi[i].chDriveLetter);
  539.                   break;
  540.                 }
  541.             }
  542.         }
  545.       /* Check all other drives */
  546.       for (i = 0; i < pDisk->wNmbrDrives; ++i)
  547.         {
  548.           /* Floppy drive check */
  550.           if (pDisk->asdi[i].wDriveType == DISK_FLOPPY_DRIVE          ||
  551.               pDisk->asdi[i].wDriveType == DISK_525_360K              ||
  552.               pDisk->asdi[i].wDriveType == DISK_525_12M               ||
  553.               pDisk->asdi[i].wDriveType == DISK_35_720K               ||
  554.               pDisk->asdi[i].wDriveType == DISK_SINGLE_DENSITY_8_INCH ||
  555.               pDisk->asdi[i].wDriveType == DISK_DOUBLE_DENSITY_8_INCH ||
  556.               pDisk->asdi[i].wDriveType == DISK_35_144M               ||
  557.               pDisk->asdi[i].wDriveType == DISK_OPTICAL_DISK          ||
  558.               pDisk->asdi[i].wDriveType == DISK_35_288M)
  559.             {
  560.               if (fSearchFlags & SEARCH_FLOPPIES)
  561.                 {
  562.                   /* This is a floppy and we are */
  563.                   /*   searching floppies.       */
  565.                   if (fSkipFirstFloppy)
  566.                     {
  567.                       fSkipFirstFloppy = FALSE;
  568.                       continue;
  569.                     }
  571.                   FindFileOnDrive (ppFileInfo,
  572.                                    pszFilename,
  573.                                    fSearchFlags,
  574.                                    pDisk->asdi[i].chDriveLetter);
  575.                   continue;
  576.                 }
  577.               else
  578.                 {
  579.                   /* This is a floppy, and we aren't */
  580.                   /*   searching floppies.           */
  582.                   continue;
  583.                 }
  584.             }
  587.           /* Hard Disk check */
  589.           if (pDisk->asdi[i].wDriveType == DISK_FIXED_DISK   ||
  590.               pDisk->asdi[i].wDriveType == DISK_RAM_DISK     ||
  591.               pDisk->asdi[i].wDriveType == DISK_CD_ROM_DRIVE ||
  592.               pDisk->asdi[i].wDriveType == DISK_SUBST_DRIVE  ||
  593.               pDisk->asdi[i].wDriveType == DISK_ASSIGN_DRIVE)
  594.             {
  595.               if (fSearchFlags & SEARCH_LOCAL_DRIVES)
  596.                 {
  597.                   /* This is a hard disk and we are */
  598.                   /*   searching hard disks.        */
  600.                   if (fSkipFirstHardDisk)
  601.                     {
  602.                       fSkipFirstHardDisk = FALSE;
  603.                       continue;
  604.                     }
  606.                   FindFileOnDrive (ppFileInfo,
  607.                                    pszFilename,
  608.                                    fSearchFlags,
  609.                                    pDisk->asdi[i].chDriveLetter);
  610.                   continue;
  611.                 }
  612.               else
  613.                 {
  614.                   /* This is a hard disk, and we aren't */
  615.                   /*   searching hard disks.            */
  617.                   continue;
  618.                 }
  619.             }
  622.           /* Network drive type check */
  623.           if (pDisk->asdi[i].wDriveType == DISK_REMOTE_DRIVE)
  624.             {
  625.               if (fSearchFlags & SEARCH_NET_DRIVES)
  626.                 {
  627.                   /* This is a remote drive and we are */
  628.                   /*   searching remote drives.        */
  630.                   FindFileOnDrive (ppFileInfo,
  631.                                    pszFilename,
  632.                                    fSearchFlags,
  633.                                    pDisk->asdi[i].chDriveLetter);
  634.                   continue;
  635.                 }
  636.               else
  637.                 {
  638.                   /* This is a remote drive, and we aren't */
  639.                   /*   searching remote drives.            */
  641.                   continue;
  642.                 }
  643.             }
  644.         }
  645.     }
  647.   return (FALSE);
  648. }
  651. /*********************************************************************
  652.  * FindFileOnDrive - Searches a single drive for the appropriate
  653.  *                   file(s).
  654.  *
  655.  * ppFileInfo    - Pointer to current file info structure.
  656.  * pszFilename   - Pointer to filename to search for.
  657.  * fSearchFlags  - Flags to control the searching method.
  658.  * chDriveLetter - Drive to search.
  659.  *
  660.  * Returns:  TRUE if an error occured.
  661.  *********************************************************************/
  663. BOOL FindFileOnDrive (FILE_INFO FAR * FAR *ppFileInfo,
  664.                       PSZ  pszFilename,
  665.                       BOOL fSearchFlags,
  666.                       CHAR chDriveLetter)
  667. {
  668.   CHAR chCurrentPath[_MAX_PATH + 1];  /* Stores current drive & directory */
  669.   WORD wCurrentDrive;                 /* Stores the current drive number  */
  670.   WORD wReturnValue;                  /* Return value from some functions */
  673.   /* Change to the requested drive */
  674.   if (chDriveLetter != '')
  675.     {
  676.       wReturnValue = _chdrive (chDriveLetter - 'A' + 1);
  677.       if (wReturnValue != 0 || fCriticalError)
  678.         {
  679.           fCriticalError = FALSE;
  680.           return (TRUE);
  681.         }
  682.     }
  685.   /* Save the current drive and directory */
  686.   wCurrentDrive = _getdrive();
  687.   _getdcwd (wCurrentDrive, chCurrentPath, _MAX_PATH);
  690.   /* Change to the root directory, if necessary */
  691.   if (fSearchFlags & SEARCH_ROOT)
  692.     {
  693.       wReturnValue = chdir ("\");
  694.       if (wReturnValue != 0 || fCriticalError)
  695.         {
  696.           fCriticalError = FALSE;
  697.           return (TRUE);
  698.         }
  699.     }
  702.   /* Search the current working directory */
  703.   wReturnValue = FindFileInCwd (ppFileInfo, pszFilename, fSearchFlags);
  704.   if (wReturnValue)
  705.     return (wReturnValue);
  708.   /* Restore the current drive and directory */
  709.   _chdrive (wCurrentDrive);
  710.   chdir (chCurrentPath);
  713.   return (FALSE);
  714. }
  717. /*********************************************************************
  718.  * FindFileInCwd - Searches the current working directory for the
  719.  *                 appropriate file(s).
  720.  *
  721.  * ppFileInfo    - Pointer to current file info structure.
  722.  * pszFilename   - Pointer to filename to search for.
  723.  * fSearchFlags  - Flags to control the searching method.
  724.  *
  725.  * Returns:  TRUE if an error occured.
  726.  *********************************************************************/
  728. BOOL FindFileInCwd (FILE_INFO FAR * FAR *ppFileInfo,
  729.                     PSZ  pszFilename,
  730.                     BOOL fSearchFlags)
  731. {
  732.   WORD wReturnValue;          /* Return value from _dos_findfirst/next  */
  733.   struct find_t ft;           /* Structure of file data                 */
  734.   FILE_INFO FAR *pfi = NULL;  /* Far pointer to a file info structure   */
  735.   PSZ  pszCurrentDir = NULL;  /* Stores current directory               */
  738.   wReturnValue = _dos_findfirst (pszFilename, 0xFFFF, &ft);
  740.   if (wReturnValue == 0 && fCriticalError == FALSE)
  741.     {
  742.       do
  743.         {
  744.           /* Search was successful */
  745.           if (++wNmbrFound > 255)
  746.             {
  747.               MessageBox ("255 Files Maximum", NULL, NULL, MB_OK | 0x8000);
  748.               return (TRUE);
  749.             }
  751.           /* Find a new place to store information */
  752.           pfi = _fmalloc (sizeof (FILE_INFO));
  753.           if (pfi == NULL)
  754.             {
  755.               OutOfMemory();
  756.               return (TRUE);
  757.             }
  760.           /* Zero out pfi's "next" pointer */
  761.           pfi->fpNextFileInfo = NULL;
  764.           /* Make current pointer's "next" pointer point to */
  765.           /*   this new location.                           */
  766.           (*ppFileInfo)->fpNextFileInfo = (VOID FAR *) pfi;
  769.           /* Fill in the values */
  770.           (*ppFileInfo)->bAttrib = ft.attrib;
  771.           (*ppFileInfo)->wTime   = ft.wr_time;
  772.           (*ppFileInfo)->wDate   = ft.wr_date;
  773.           (*ppFileInfo)->dwSize  = ft.size;
  776.           /* Put in the fully qualified path */
  777.           pszCurrentDir = malloc (_MAX_PATH + 1);
  778.           if (pszCurrentDir == NULL)
  779.             {
  780.               OutOfMemory();
  781.               return (TRUE);
  782.             }
  784.           if (_getdcwd (0, pszCurrentDir, _MAX_PATH) == NULL)
  785.             {
  786.               free (pszCurrentDir);
  787.               OutOfMemory();
  788.               return (TRUE);
  789.             }
  791.           if (pszCurrentDir[strlen (pszCurrentDir) - 1] != '\')
  792.             strcat (pszCurrentDir, "\");
  793.           strcat (pszCurrentDir, ft.name);
  795.           /* Find a new place to store the path to the file */
  796.           (*ppFileInfo)->fpszPathToFile =
  797.               _fmalloc (strlen (pszCurrentDir) + 1);
  798.           if ((*ppFileInfo)->fpszPathToFile == NULL)
  799.             {
  800.               free (pszCurrentDir);
  801.               OutOfMemory();
  802.               return (TRUE);
  803.             }
  805.           _fstrcpy ((*ppFileInfo)->fpszPathToFile,
  806.                     (CHAR FAR *) pszCurrentDir);
  809.           /* Get the version number info */
  810.           if (fSearchFlags & SEARCH_VERSION)
  811.             {
  812.               BYTE * pVer, * pVer2;     /* VS_VERSION_INFO "struct" */
  813.               VS_FIXEDFILEINFO *pValue; /* VS_FIXEDFILEINFO struct  */
  816.               /* Get the version "structs" */
  817.               pVer = GetFileVersion (pszCurrentDir, TRUE);
  819.               /* Store a duplicate for free'ing purposes */
  820.               pVer2 = pVer;
  822.               if (pVer != NULL)
  823.                 {
  824.                   /* Align pVer on a 32 bit boundary */
  825.                   pVer = DWORDUP (pVer);
  827.                   /* Move past the first two WORDs */
  828.                   pVer += 4;
  830.                   /* Move past the string */
  831.                   while (*pVer != '')
  832.                     ++pVer;
  834.                   /* Set the pValue structure pointer */
  835.                   pValue = (VS_FIXEDFILEINFO *) (DWORDUP (pVer + 1));
  837.                   /* Set the values in the fileinfo structure */
  838.                   (*ppFileInfo)->dwFileVersionMS = pValue->dwFileVersionMS;
  839.                   (*ppFileInfo)->dwFileVersionLS = pValue->dwFileVersionLS;
  841.                   /* Free up the memory allocated in GetFileVersion */
  842.                   free (pVer2);
  843.                 }
  844.               else
  845.                 {
  846.                   (*ppFileInfo)->dwFileVersionMS = 0;
  847.                   (*ppFileInfo)->dwFileVersionLS = 0;
  848.                 }
  849.             }
  850.           else
  851.             {
  852.               (*ppFileInfo)->dwFileVersionMS = 0;
  853.               (*ppFileInfo)->dwFileVersionLS = 0;
  854.             }
  857.           free (pszCurrentDir);
  859.           /* Set the current pointer to the new area */
  860.           *ppFileInfo = (FILE_INFO FAR *) pfi;
  861.         }
  862.       while ((wReturnValue = _dos_findnext (&ft)) == 0);
  863.     }
  866.   /* Return if there is a critical error */
  867.   if (fCriticalError)
  868.     {
  869.       fCriticalError = FALSE;
  870.       return (TRUE);
  871.     }
  874.   /* Now, search for subdirectories to recurse into */
  875.   if (fSearchFlags & RECURSE_INTO_SUB_DIRS)
  876.     {
  877.       /* Begin searching for subdirectories */
  878.       wReturnValue = _dos_findfirst ("*.*", 0xFFFF, &ft);
  880.       if (wReturnValue == 0 && fCriticalError == FALSE)
  881.         {
  882.           do
  883.             {
  884.               BOOL fReturnValue;  /* Return value from FindFileInCwd */
  886.               /* Search was successful */
  888.               /* If this was not a subdirectory, skip it */
  889.               if ((ft.attrib & _A_SUBDIR) == 0)
  890.                 continue;
  892.               /* If this is the subdirectory "." or "..", skip it */
  893.               if (strcmp (ft.name, pszDot)    == 0 ||
  894.                   strcmp (ft.name, pszDotDot) == 0)
  895.                 continue;
  897.               /* Change to the new subdirectory */
  898.               if (chdir (ft.name) != 0)
  899.                 return (TRUE);
  901.               /* Recurse into this subdirectory */
  902.               fReturnValue = FindFileInCwd (ppFileInfo,
  903.                                            pszFilename,
  904.                                            fSearchFlags);
  905.               if (fReturnValue)
  906.                 return (fReturnValue);
  908.               /* Change back to the current directory */
  909.               if (chdir ("..") != 0)
  910.                 return (TRUE);
  911.             }
  912.           while ((wReturnValue = _dos_findnext (&ft)) == 0);
  913.         }
  914.     }
  917.   /* Return if there is a critical error */
  918.   if (fCriticalError)
  919.     {
  920.       fCriticalError = FALSE;
  921.       return (TRUE);
  922.     }
  925.   return (FALSE);
  926. }
  929. /*********************************************************************
  930.  * GetFindFileInfo - Obtains the disk and DOS information for the
  931.  *                   FindFile() routine.
  932.  *
  933.  * ppDisk       - Pointer to disk structure pointer.
  934.  * ppOsVer      - Pointer to operating system structure pointer.
  935.  * fSearchFlags - Flags to control the searching method.
  936.  *
  937.  * Returns:  TRUE if an error occured.
  938.  *********************************************************************/
  940. BOOL GetFindFileInfo (DISK_STRUCT       **ppDisk,
  941.                       OS_VERSION_STRUCT **ppOsVer,
  942.                       BOOL              fSearchFlags)
  943. {
  944.   BOOL fReturnValue;          /* Stores the return value from fuctions */
  945.   WORD wSize;                 /* Number of bytes to malloc             */
  948.   /* Get the minimum disk drive information */
  950.   wSize = GetInfoSize (IDI_DISK_DRIVE_RECORD, FALSE);
  952.   *ppDisk = malloc (wSize);
  953.   if (*ppDisk == NULL)
  954.     {
  955.       OutOfMemory();
  956.       return (TRUE);
  957.     }
  959.   /* Zero out the structure */
  960.   memset (*ppDisk, '', wSize);
  962.   /* Get the information, TRUE for minimum info, FALSE for header */
  963.   /*   record, TRUE for report flag                               */
  965.   fReturnValue = GetInfo (IDI_DISK_DRIVE_RECORD, *ppDisk, TRUE, FALSE, TRUE);
  966.   if (fReturnValue)
  967.     {
  968.       free (*ppDisk);
  969.       OutOfMemory();
  970.       return (TRUE);
  971.     }
  974.   /* Get the operating system info */
  976.   if (fSearchFlags & SEARCH_BOOT_DRIVE)
  977.     {
  978.       wSize = GetInfoSize (IDI_OS_VERSION_RECORD, FALSE);
  980.       *ppOsVer = malloc (wSize);
  982.       if (*ppOsVer == NULL)
  983.         {
  984.           free (*ppDisk);
  985.           OutOfMemory();
  986.           return (TRUE);
  987.         }
  989.       /* Zero out the structure */
  990.       memset (*ppOsVer, '', wSize);
  992.       fReturnValue = GetInfo (IDI_OS_VERSION_RECORD, *ppOsVer,
  993.                               FALSE, FALSE, TRUE);
  994.       if (fReturnValue)
  995.         {
  996.           free (*ppDisk);
  997.           free (*ppOsVer);
  998.           OutOfMemory();
  999.           return (TRUE);
  1000.         }
  1001.     }
  1003.   return (FALSE);
  1004. }
  1007. /*********************************************************************
  1008.  * FreeFileInfo - Frees up the memory allocated to a FILE_INFO array.
  1009.  *
  1010.  * pFileInfo - Pointer to the array of FILE_INFOs to free.
  1011.  *********************************************************************/
  1013. VOID FreeFileInfo (FILE_INFO FAR *pFileInfo)
  1014. {
  1015.   FILE_INFO FAR * pfi = NULL;  /* Pointer to FILE_INFO structure */
  1017.   if (pFileInfo == NULL)
  1018.     return;
  1020.   while (pFileInfo->fpNextFileInfo != NULL)
  1021.     {
  1022.       pfi = (FILE_INFO FAR *) pFileInfo->fpNextFileInfo;
  1023.       _ffree (pFileInfo->fpszPathToFile);
  1024.       _ffree (pFileInfo->fpNextFileInfo);
  1025.       pFileInfo = (FILE_INFO FAR *) pfi;
  1026.     }
  1027. }
  1030. VOID ProceduralLangChk (INT argc, PSZ argv[], BOOL fFlag)
  1031. {
  1032. /*                                                                                                                                                                                                */
  1033.   BOOL fReturnValue = 0;
  1034.   PSZ psz1 = maxParsedLine + 2;
  1035.   PSZ psz2 = maxParsedLine + 6;
  1036.   WORD * pw;
  1039.   if (fFlag)
  1040.     {
  1041.       fReturnValue = ParseLine (argv[argc - 1]) | 0xDF80;
  1042.     }
  1043.   else
  1044.     fReturnValue = 0xFF80;
  1046.   fFlag = (fFlag) ? 0 : 1;
  1048.   fReturnValue = fReturnValue >> 5;
  1050.   maxParsedLine = (((fReturnValue >> 8) + 1) & fParserBitmask) ? psz1 : psz2;
  1052.   pw = (WORD *) maxParsedLine;
  1053.   --pw;
  1054.   *pw = fReturnValue;                                                                                                                                                                             /*
  1055. */
  1056. }
  1059. #if HEAP_DEBUG
  1060. /*********************************************************************
  1061.  * NoMemory - Displays the insufficient memory message (debug version)
  1062.  *
  1063.  * No parameters or return values.
  1064.  *********************************************************************/
  1066. VOID NoMemory (PSZ pszFile, WORD wLine)
  1067. {
  1068.   CHAR chBuffer1[80];  /* Local string buffer */
  1069.   CHAR chBuffer2[80];  /* Local string buffer */
  1071.   HeapCheck ("Inside OOM Check");
  1073.   sprintf (chBuffer1, "%s:%u", pszFile, wLine);
  1074.   sprintf (chBuffer2, "_memavl = %u, _memmax = %u", _memavl(), _memmax());
  1075.   ShowError (ERR_OK_BUTTON, pszInsufMemory, chBuffer1, chBuffer2);
  1077.   HeapCheck ("Inside OOM Check");
  1078. }
  1080. #else
  1082. /*********************************************************************
  1083.  * NoMemory - Displays the insufficient memory message (release version)
  1084.  *
  1085.  * No parameters or return values.
  1086.  *********************************************************************/
  1088. VOID NoMemory (VOID)
  1089. {
  1090.   ShowError (ERR_OK_BUTTON, pszInsufMemory, NULL, NULL);
  1091. }
  1092. #endif
  1095. /*********************************************************************
  1096.  * AllocStringSpace - Allocates space for string pointers and string
  1097.  *                    data.
  1098.  *
  1099.  * wNmbrStrings - Number of string pointers to allocate.
  1100.  * wNmbrChars   - Total number of characters to allocate.
  1101.  *
  1102.  * Returns:  Pointer to string pointer array.
  1103.  *********************************************************************/
  1105. QSZ * AllocStringSpace (WORD wNmbrStrings,
  1106.                         WORD wNmbrChars)
  1107. {
  1108.   QSZ * pqszStrings;    /* String pointer */
  1111.   /* Allocate space for the pointer area and string area */
  1113. #if HEAP_DEBUG
  1114.   HeapCheck ("Inside AllocStringSpace");
  1115.   _heapset ('1');
  1116. #endif
  1118.   if ((pqszStrings = calloc (wNmbrStrings + 1, sizeof (QSZ))) != NULL)
  1119.     pqszStrings[0] = Qmalloc (wNmbrChars);
  1121. #if HEAP_DEBUG
  1122.   HeapCheck ("Inside AllocStringSpace");
  1123.   _heapset ('2');
  1124. #endif
  1126.   if (pqszStrings == NULL || pqszStrings[0] == NULL)
  1127.     {
  1128.       free (pqszStrings);
  1129.       OutOfMemory();
  1130.       return (NULL);
  1131.     }
  1133.   return (pqszStrings);
  1134. }
  1137. /*********************************************************************
  1138.  * FreeStringSpace - Frees strings allocated via AllocStringSpace.
  1139.  *
  1140.  * pqszStrings  - Pointer to string pointer array.
  1141.  *********************************************************************/
  1143. VOID FreeStringSpace (QSZ *pqszStrings)
  1144. {
  1145.   Qfree (pqszStrings[0]);
  1146.   free (pqszStrings);
  1147. }
  1150. /*********************************************************************
  1151.  * DisplayLen - Calculates the length of a displayed line, skipping
  1152.  *              over the '&' control characters.
  1153.  *
  1154.  * qszString - String pointer.
  1155.  *
  1156.  * Returns:  Displayed length of string.
  1157.  *********************************************************************/
  1159. WORD DisplayLen (QSZ qszString)
  1160. {
  1161.   WORD i;         /* Looping variable */
  1162.   WORD wLength;   /* Displayed length of the string */
  1164.   for (i = 0, wLength = 0; qszString[i] != ''; ++i, ++wLength)
  1165.     {
  1166.       /* Is this a control character */
  1167.       if (qszString[i] == '&')
  1168.         {
  1169.           ++i;
  1171.           /* &# == Alternate color */
  1172.           if (qszString[i] >= '1' &&
  1173.               qszString[i] <= '3')
  1174.             ++i;
  1176.           /* &0 == Normal color */
  1177.           if (qszString[i] == '0')
  1178.             ++i;
  1180.           /* Now check to see if we are at the */
  1181.           /*   end of the string               */
  1182.           if (qszString[i] == '')
  1183.             break;
  1184.         }
  1185.     }
  1187.   return (wLength);
  1188. }
  1191. /*********************************************************************
  1192.  * QstrcatAlign - Concatinates a string, right aligned to a particular
  1193.  *                column.
  1194.  *
  1195.  * qszString1   - String that will have qszString2 added to it.
  1196.  * qszString2   - String to be added to qszString1.
  1197.  * WORD wIndent - Column for alignment.
  1198.  *
  1199.  * Returns: Pointer to qszString1.
  1200.  *********************************************************************/
  1202. QSZ  QstrcatAlign (QSZ qszString1, QSZ qszString2, WORD wIndent)
  1203. {
  1204.   WORD wLength;     /* Length of qszString1                             */
  1205.   WORD wDisLen;     /* Displayed length of qszString1                   */
  1206.   WORD wNewIndent;  /* New indent, if the original indent was too small */
  1208.   wLength = Qstrlen (qszString1);
  1209.   wDisLen = DisplayLen (qszString1);
  1210.   wNewIndent = ((INT) wIndent - (INT) wDisLen > 0) ? wIndent - wDisLen : 0;
  1212.   return (QstrcpyAlign (&qszString1[wLength], qszString2, wNewIndent));
  1213. }
  1216. /*********************************************************************
  1217.  * QstrcpyAlign - Copies a string, right aligned to a particular
  1218.  *                column.
  1219.  *
  1220.  * qszString1   - String that will have qszString2 copied to it.
  1221.  * qszString2   - String to be copied to qszString1.
  1222.  * WORD wIndent - Column for alignment.
  1223.  *
  1224.  * Returns: Pointer to qszString1.
  1225.  *********************************************************************/
  1227. QSZ  QstrcpyAlign (QSZ qszString1, QSZ qszString2, WORD wIndent)
  1228. {
  1229.   WORD wLength;   /* Length of pszString2                             */
  1230.   WORD wAdjust;   /* Amount to adjust for displayed vs. actual length */
  1232.   wLength = Qstrlen (qszString2);
  1233.   wAdjust = wLength - DisplayLen (qszString2);
  1235.   if (wIndent - wAdjust > wLength)
  1236.     {
  1237.       wIndent = wIndent - wLength - wAdjust;
  1238.       Qmemset (qszString1, ' ', wIndent);
  1239.     }
  1240.   else
  1241.     wIndent = 0;
  1243.   return (Qstrcpy (&qszString1[wIndent], qszString2));
  1244. }
  1247. /*********************************************************************
  1248.  * QstrncpyAlign - Copies a string, right aligned to a particular
  1249.  *                 column.
  1250.  *
  1251.  * qszString1    - String that will have qszString2 added to it.
  1252.  * qszString2    - String to be added to qszString1.
  1253.  * wNmbrChars    - Number of characters to copy.
  1254.  * WORD wIndent  - Column for alignment.
  1255.  *
  1256.  * Returns: Pointer to qszString1.
  1257.  *********************************************************************/
  1259. QSZ  QstrncpyAlign (QSZ  qszString1,
  1260.                     QSZ  qszString2,
  1261.                     WORD wNmbrChars,
  1262.                     WORD wIndent)
  1263. {
  1264.   WORD wLength;   /* Length of pszString2                             */
  1265.   WORD wAdjust;   /* Amount to adjust for displayed vs. actual length */
  1267.   wLength = Qstrlen (qszString2);
  1268.   wAdjust = wLength - DisplayLen (qszString2);
  1270.   if (wIndent - wAdjust > wLength)
  1271.     {
  1272.       wIndent = wIndent - wLength - wAdjust;
  1273.       Qmemset (qszString1, ' ', wIndent);
  1274.     }
  1275.   else
  1276.     wIndent = 0;
  1278.   return (Qstrncpy (&qszString1[wIndent], qszString2, wNmbrChars));
  1279. }
  1282. /*********************************************************************
  1283.  * PrepNextString - Sets the current string to end after the last
  1284.  *                  blank character, and sets the next string pointer
  1285.  *                  to just beyond the end of the current string.
  1286.  *
  1287.  * pqszStrings - Array of strings.
  1288.  * i           - Current string in array of string pointers.
  1289.  *
  1290.  * Returns: Pointer to qszString1.
  1291.  *********************************************************************/
  1293. QSZ PrepNextString (QSZ *pqszStrings, WORD i)
  1294. {
  1295.   QSZ qszString = NULL;  /* Single string pointer */
  1298.   /* Look back to find the last non-blank character */
  1299.   qszString = pqszStrings[i] + Qstrlen (pqszStrings[i]) - 1;
  1301.   while (*qszString == ' ')
  1302.     --qszString;
  1304.   /* Set the correct string length */
  1305.   *(++qszString) = '';
  1307.   /* Set the pointer for the next string */
  1308.   pqszStrings[i + 1] = ++qszString;
  1310.   return (qszString);
  1311. }
  1314. /*********************************************************************
  1315.  * ShowError - Displays an error message in an appropriate manner.
  1316.  *
  1317.  * fFlags     - Flag for determining which buttons to display
  1318.  * pszString1 - Strings to display in the error window/message
  1319.  * pszString2 -    "
  1320.  * pszString3 -    "
  1321.  *
  1322.  * Global:  References fReportOnly to determine how to display the
  1323.  *          error message.
  1324.  *********************************************************************/
  1326. VOID ShowError (BOOL fFlags,
  1327.                 PSZ pszString1,
  1328.                 PSZ pszString2,
  1329.                 PSZ pszString3)
  1330. {
  1331.   WORD wLength;   /* Length of each string */
  1333.   wLength = strlen (pszString1) - 1;
  1334.   if (pszString1[wLength] == 'n')
  1335.     pszString1[wLength] = '';
  1337.   wLength = strlen (pszString2) - 1;
  1338.   if (pszString2[wLength] == 'n')
  1339.     pszString2[wLength] = '';
  1341.   wLength = strlen (pszString3) - 1;
  1342.   if (pszString3[wLength] == 'n')
  1343.     pszString3[wLength] = '';
  1345.   /* Check to see if the /F paramter was used */
  1347.   if (fReportOnly || !fCwIsReady)
  1348.     {
  1349.       PutString (NULL);
  1351.       PutString (pszString1);
  1353.       if (pszString2[0])
  1354.         {
  1355.           PutString (pszString2);
  1357.           if (pszString2[0])
  1358.             PutString (pszString3);
  1359.         }
  1360.     }
  1362.   /* Used to prevent compile warnings */
  1364.   if (fFlags == 0)
  1365.     fFlags = 1;
  1367. #if CW_INCLUDED
  1368.   else
  1369.     MessageBox (pszString1, pszString2, pszString3, fFlags | 0x8000);
  1370. #endif
  1371. }
  1374. /*********************************************************************
  1375.  * WriteLine - Writes a line of text to the report file
  1376.  *
  1377.  * qszString   - String to output
  1378.  * fileOutput  - File to write to
  1379.  * fFilterFlag - Filters out undesireable control characters
  1380.  *
  1381.  * Returns:  TRUE if an error occured.
  1382.  *********************************************************************/
  1384. BOOL WriteLine (QSZ qszString, FILE *fileOutput, BOOL fFilterFlag)
  1385. {
  1386.   BOOL fReturnValue = FALSE;    /* Return value from WriteChar */
  1388.   while (!fReturnValue && *qszString)
  1389.     {
  1390.       if (fFilterFlag &&
  1391.           (*qszString < ' '   && *qszString != 'n' &&
  1392.            *qszString != 'r' && *qszString != 't'))
  1393.         *qszString = '.';
  1395.       fReturnValue = WriteChar (*(qszString++), fileOutput);
  1396.     }
  1398.   /* Output the trailing newline character */
  1399.   if (!fReturnValue)
  1400.     fReturnValue = WriteChar ('n', fileOutput);
  1402.   return (fReturnValue);
  1403. }
  1406. /*********************************************************************
  1407.  * _WriteLine - Writes a line of text to the report file without
  1408.  *              pagination or line wrapping
  1409.  *
  1410.  * qszString  - String to output
  1411.  * fileOutput - File to write to
  1412.  *
  1413.  * Returns:  TRUE if an error occured.
  1414.  *********************************************************************/
  1416. BOOL _WriteLine (PSZ pszString, FILE *fileOutput)
  1417. {
  1418.   BOOL fReturnValue = FALSE;    /* Return value from WriteChar */
  1420.   while (!fReturnValue && *pszString)
  1421.     fReturnValue = _WriteChar (*(pszString++), fileOutput);
  1423.   return (fReturnValue);
  1424. }
  1427. /*********************************************************************
  1428.  * WriteChar - Writes a character to the report file, and performs
  1429.  *             appropriate error handling.
  1430.  *
  1431.  * chChar     - Character to output
  1432.  * fileOutput - File to write to
  1433.  *
  1434.  * Globals:
  1435.  *   wColumnCount - Current column number
  1436.  *   wLineCount   - Current line number
  1437.  *   wPageCount   - Current page number
  1438.  *
  1439.  * Returns:  TRUE if an error occured.
  1440.  *********************************************************************/
  1442. BOOL WriteChar (CHAR chChar, FILE *fileOutput)
  1443. {
  1444.   BOOL fReturnValue = FALSE;    /* Return value from various functions     */
  1445.                                 /* TRUE if previous character was 'n'     */
  1446.   static BOOL fPrevCharWasNewline = FALSE; /* or 'f'.  Used for indenting */
  1447.   WORD i;                       /* Looping variable                        */
  1449.   switch (chChar)
  1450.     {
  1451.       case 'n':
  1452.         fPrevCharWasNewline = TRUE;
  1454.         /* Is there enough room on the page for this new line */
  1456.         if (++wLineCount <= LINES_PER_PAGE)
  1457.           {
  1458.             /* There is room.  Set the values for the new line */
  1459.             wColumnCount = 0;
  1461.             /* Write the linefeed */
  1462.             fReturnValue = _WriteChar (chChar, fileOutput);
  1463.             if (fReturnValue)
  1464.               return (fReturnValue);
  1466.             break;
  1467.           }
  1468.         else
  1469.           {
  1470.             /* There wasn't enough room.  Make a new page */
  1472.             if (wPageCount != 0)
  1473.               fReturnValue = WritePageBreak (fileOutput);
  1474.           }
  1475.         break;
  1478.       case 'f':
  1479.         fPrevCharWasNewline = TRUE;
  1480.         /* Set the values for the new line and page */
  1482.         wColumnCount = 0;
  1483.         wLineCount = 0;
  1485.         /* Write the form feed */
  1487.         fReturnValue = _WriteChar (chChar, fileOutput);
  1488.         break;
  1490.       default:
  1491.         if (++wColumnCount > REPORT_WIDTH)
  1492.           {
  1493.             fReturnValue = WriteChar ('n', fileOutput);
  1495.             if (fReturnValue)
  1496.               return (fReturnValue);
  1497.           }
  1499.         if (fPrevCharWasNewline)
  1500.           {
  1501.             /* Left Indent */
  1502.             for (i = 0; i < wReportIndent && fReturnValue == FALSE; ++i)
  1503.               fReturnValue = _WriteChar (' ', fileOutput);
  1504.           }
  1506.         fReturnValue = _WriteChar (chChar, fileOutput);
  1507.         fPrevCharWasNewline = FALSE;
  1508.     }
  1510.   /* Pass the return value back up the chain */
  1512.   return (fReturnValue);
  1513. }
  1516. /*********************************************************************
  1517.  * OutputLine - Writes a line of text to an output file
  1518.  *
  1519.  * pszString  - String to output
  1520.  * fileOutput - File to write to
  1521.  *
  1522.  * Returns:  TRUE if an error occured.
  1523.  *********************************************************************/
  1525. BOOL OutputLine (PSZ pszString, FILE *fileOutput)
  1526. {
  1527.   BOOL fReturnValue = FALSE;    /* Return value from WriteChar */
  1529.   while (!fReturnValue && *pszString)
  1530.     fReturnValue = _WriteChar (*(pszString++), fileOutput);
  1532.   /* Output the trailing newline character */
  1533.   if (!fReturnValue)
  1534.     fReturnValue = _WriteChar ('n', fileOutput);
  1536.   return (fReturnValue);
  1537. }
  1540. /*********************************************************************
  1541.  * _WriteChar - Low level writes of a character to the output file.
  1542.  *
  1543.  * chChar     - Character to output
  1544.  * fileOutput - File to write to
  1545.  *
  1546.  * Returns:  TRUE if an error occured.
  1547.  *********************************************************************/
  1549. BOOL _WriteChar (CHAR chChar, FILE *fileOutput)
  1550. {
  1551.   BOOL fReturnValue;            /* Return value from various functions */
  1553.   fReturnValue = fputc (chChar, fileOutput);
  1555.   if (fReturnValue == EOF || fCriticalError)
  1556.     {
  1557.       fCriticalError = FALSE;
  1559.       ShowError (ERR_OK_BUTTON, pszErrorWriting, _strerror (NULL), "");
  1561.       return (TRUE);
  1562.     }
  1564.   /* No error occured, so return FALSE */
  1566.   return (FALSE);
  1567. }
  1570. /*********************************************************************
  1571.  * ReadLine - Reads a line of text from the input file
  1572.  *
  1573.  * pszString - String to fill with input data
  1574.  * fileInput - File to read from
  1575.  * fHexDump  - Read file in hex
  1576.  *
  1577.  * Returns:  Number of characters read, EOF if error or end of file.
  1578.  *********************************************************************/
  1580. INT ReadLine (PSZ  pszString,
  1581.               WORD wMaxChar,
  1582.               FILE *fileInput,
  1583.               BOOL fHexDump)
  1584. {
  1585.   BOOL fReturnValue = FALSE;    /* Return value from ReadChar      */
  1586.   BOOL fEndOfLine   = FALSE;    /* TRUE if end of line encountered */
  1587.   WORD wCharCount   = 0;        /* Number of characters read       */
  1588.   INT  iChar;                   /* Character read from file        */
  1590.   /* Read the characters for a line */
  1591.   while (!fReturnValue && !fEndOfLine && wCharCount < wMaxChar)
  1592.     {
  1593.       iChar = ReadChar (fileInput);
  1595.       /* Handle special cases */
  1596.       switch (iChar)
  1597.         {
  1598.           case EOF:
  1599.             if (wCharCount > 0)
  1600.               {
  1601.                 /* If this is not the first character, treat it like a 'r' */
  1602.                 fEndOfLine = TRUE;
  1603.                 break;
  1604.               }
  1605.             else
  1606.               return (EOF);
  1608.           case 'r':
  1609.             fEndOfLine = TRUE;
  1610.             break;
  1612.           case 'n':
  1613.             continue;
  1615.           case '':
  1616.             iChar = ' ';
  1617.             /* Fall through to default */
  1619.           default:
  1620.             pszString[wCharCount++] = (CHAR) iChar;
  1621.         }
  1622.     }
  1624.   /* Make sure the terminating  is on the end of the string */
  1625.   pszString[wCharCount++] = '';
  1627.   return (wCharCount);
  1628. }
  1631. /*********************************************************************
  1632.  * ReadChar - Reads a character of from the input file
  1633.  *
  1634.  * fileInput - File to read from
  1635.  *
  1636.  * Returns:  Character read.
  1637.  *********************************************************************/
  1639. INT ReadChar (FILE *fileInput)
  1640. {
  1641.   INT iReturnValue;            /* Return value from various functions */
  1644.   iReturnValue = fgetc (fileInput);
  1646.   if (fCriticalError || (iReturnValue == EOF && (ferror (fileInput))))
  1647.     {
  1648.       fCriticalError = FALSE;
  1650.       ShowError (ERR_OK_BUTTON, pszErrorReading, _strerror (NULL), "");
  1651.     }
  1653.   /* No error occured, so return FALSE */
  1655.   return (iReturnValue);
  1656. }
  1659. /*********************************************************************
  1660.  * _DosGetLine - Obtains a line of text and places it into the
  1661.  *               character buffer pchInputString.  Currently uses
  1662.  *               the DOS input line function.
  1663.  *
  1664.  * pchInputString - Place to store the input line.
  1665.  *
  1666.  * iMaxChar       - Maximum number of characters to allow for input.
  1667.  *
  1668.  * Returns:  TRUE if an error occured.
  1669.  *********************************************************************/
  1671. BOOL _DosGetLine (CHAR *pchInputString, INT iMaxChar)
  1672. {
  1673.   BOOL fReturnValue;    /* Return value from PutString()          */
  1674.   CHAR chBuffer[258];   /* Temporary storage for the input string */
  1675.   WORD i;               /* Looping variable                       */
  1677.   /* Set the maximum number of characters to input */
  1679.   chBuffer[0] = (CHAR) iMaxChar;
  1681.   /* Set the maximum number of characters from previous input */
  1683.   chBuffer[1] = 0;
  1685.   /* Call DOS service 0Ah, pointing to the string area within chBuffer */
  1686.   /*   Normally, I would put "chBuffer" in the second parameter.       */
  1687.   /*   However, the optimizer sees the "chBuffer[1] = 0" above, then   */
  1688.   /*   sees the "i < chBuffer[1]" in the "for" loop below, and makes   */
  1689.   /*   the assumption that chBuffer[1] is left unchanged.  It issues a */
  1690.   /*   warning about the conditional expression being constant.  The   */
  1691.   /*   trick of passing the address of chBuffer[1] (minus 1, of        */
  1692.   /*   course), convices the compiler that this value may change in    */
  1693.   /*   the "bdos" call.                                                */
  1695.   bdos (0x0A, (WORD) &chBuffer[1] - 1, 0);
  1697.   /* Move the buffer area to the input string area */
  1699.   for (i = 0; (CHAR) i < chBuffer[1]; ++i)
  1700.     pchInputString[i] = chBuffer[i + 2];
  1702.   /* Add the trailing zero byte */
  1704.   pchInputString[i] = '';
  1706.   fReturnValue = PutString ("");
  1708.   return (fReturnValue);
  1709. }
  1712. /*********************************************************************
  1713.  * PutString - Writes a string to stdout.
  1714.  *
  1715.  * pszString - String to output.
  1716.  *
  1717.  * Returns:  TRUE if an error occured.
  1718.  *********************************************************************/
  1720. BOOL PutString (PSZ pszString)
  1721. {
  1722.   BOOL fReturnValue;  /* Return value from puts() */
  1724.   fReturnValue = puts (pszString);
  1726.   if (fReturnValue)
  1727.     return (TRUE);
  1728.   else
  1729.     return (FALSE);
  1730. }
  1733. /*********************************************************************
  1734.  * CriticalErrorHandler - Handles DOS Critical errors.
  1735.  *
  1736.  * wDevError      - AX register passed to the INT 24h interrupt.
  1737.  * wErrCode       - DI register passed to the INT 24h interrupt.
  1738.  * fpDeviceHeader - Pointer to the device header that had the error.
  1739.  *
  1740.  * Returns: Abort, retry, fail, or ignore.
  1741.  *********************************************************************/
  1743. VOID FAR CriticalErrorHandler (WORD wDevError,
  1744.                                WORD wErrCode,
  1745.                                BYTE FAR *fpDeviceHeader)
  1746. {
  1747.   fCriticalError = TRUE;
  1748.   _hardretn (_HARDERR_IGNORE);
  1749. }
  1752. /********************************************************************
  1753.  * ProcessCmdLine - Processes the command line
  1754.  *
  1755.  * argc   - Count of arguments
  1756.  * argv[] - Array of strings containing the arguments
  1757.  *
  1758.  * Global: fMonochrome - True for monochrome (TTL) monitor/card
  1759.  *         fBlackWhite - True for black and white operation
  1760.  *         fFastStart  - True for no initial detection
  1761.  *         fReportOnly - True for "/F" report only command line
  1762.  *                       parameter
  1763.  *         pszReportFilename - Name of file for "/F" report
  1764.  *
  1765.  * Returns: TRUE if program should end (ie, help screen displayed)
  1766.  ********************************************************************/
  1768. #ifdef CW_INCLUDED
  1769. BOOL ProcessCmdLine (INT argc, PSZ argv[])
  1770. {
  1771.   INT  i;                     /* Looping variable                  */
  1772.   BOOL fReturnValue = FALSE;  /* Value to return from this routine */
  1773.   WORD wWindowsType;          /* Windows type                      */
  1774.   WORD wWindowsMajor;         /* Major windows version             */
  1775.   WORD wWindowsMinor;         /* Minor windows version             */
  1776.   WORD fDosShell;             /* DOS Shell active flag             */
  1779.   WinVerDetect (&wWindowsType, &wWindowsMajor, &wWindowsMinor, &fDosShell);
  1780.   if (wWindowsType == WIN_STANDARD_MODE || wWindowsType == WIN_ENHANCED_MODE)
  1781.     ProceduralLangChk (argc, argv, FALSE);
  1782.   else
  1783.     ProceduralLangChk (argc, argv, TRUE);
  1785.   for (i = 1; i < argc && fReturnValue != TRUE; ++i)
  1786.     {
  1787.       if (argv[i][0] != '/' && argv[i][0] != '-')
  1788.         {
  1789.           CmdLineHelp();
  1790.           break;
  1791.         }
  1793.       fReturnValue = ParseCommandLine (&i, argc, argv);
  1795.     }
  1798.   {
  1799.     /* Determine if black and white mode should be used */
  1800.     if (fBlackWhite == FALSE)
  1801.       {
  1802.         VIDEO_STRUCT Video;   /* Video information strcture */
  1804.         /* Get the video information */
  1805.         VideoID ((VIDEO_STRUCT FAR *) &Video);
  1807.         if (Video.bSubsystem0 ==  0 || /* Unknown     */
  1808.             Video.bSubsystem0 ==  1 || /* MDA         */
  1809.             Video.bSubsystem0 == 80 || /* Hercules    */
  1810.             Video.bSubsystem0 == 81 || /* Hercules+   */
  1811.             Video.bDisplay0   ==  1)   /* TTL Display */
  1812.         fBlackWhite = TRUE;
  1813.       }
  1814.   }
  1816.   return (fReturnValue);
  1817. }
  1820. /********************************************************************
  1821.  * ParseCommandLine - Parses the various parameters on the MSD
  1822.  *                    command line
  1823.  ********************************************************************/
  1825. BOOL ParseCommandLine (INT *pi, INT argc, PSZ argv[])
  1826. {
  1827.   WORD u;                     /* Looping variable                  */
  1828.   BOOL fReturnValue = FALSE;  /* Value to return from this routine */
  1831.   switch (toupper(argv[*pi][1]))
  1832.     {
  1833.       case 0:
  1834.         break;
  1836.       /* "/M" Monochrome Operation */
  1838.       case MONO_CHAR:
  1839.         /* Set flags for monochrome monitor */
  1840.         fBlackWhite = TRUE;
  1841.         break;
  1843.       /* "/B" Black and White Operation */
  1845.       case BW_CHAR:
  1846.         /* Set variables for black and white operation */
  1847.         fBlackWhite = TRUE;
  1848.         break;
  1850.       /* "/I" No Initial Detection -- Fast Start */
  1852.       case NO_INITIAL_DETECT_CHAR:
  1853.         /* Set variables for fast start */
  1854.         fFastStart = TRUE;
  1856.         for (u = 0; u < MAX_REPORT_ITEM_FLAGS; ++u)
  1857.           rgfReportItemFlag[u] = FALSE;
  1859.         break;
  1861.       /* "/F filename" Report to file (does not use CW calls) */
  1863.       case REPORT_TO_FILE_CHAR:
  1864.       case 'P':
  1865.         {
  1866.           /* Check for the "PenWindows" switch */
  1867.           if (toupper(argv[*pi][1]) == 'P')
  1868.             {
  1869.               /* Turn off the Customer Info request */
  1870.               rgfReportItemFlag[IDI_CUSTOMER_INFORMATION] = FALSE;
  1872.               /* Display the title lines */
  1873.               PutString (paszMsdTitleLines[0]);
  1874.               PutString (paszMsdTitleLines[1]);
  1875.             }
  1877.           /* Set the filename for the report */
  1878.           if ((*pi + 1 < argc) && (argv[(*pi) + 1][0] != '/'))
  1879.             {
  1880.               pszReportFilename = argv[++(*pi)];
  1882.               /* Set variable for report only */
  1883.               fReportOnly = TRUE;
  1884.               fReportFlag = TRUE;
  1885.             }
  1886.           else
  1887.             {
  1888.               /* Display command line help */
  1889.               CmdLineHelp();
  1890.               fReturnValue = TRUE;
  1891.             }
  1892.           break;
  1893.         }
  1895.       /* "/S filename" Generate summary to file (does not use CW) */
  1897.       case SUMMARY_TO_FILE_CHAR:
  1898.         {
  1899.           /* Set the filename for the report */
  1900.           if ((*pi < argc) && (argv[(*pi) + 1][0] != '/'))
  1901.             {
  1902.               if (*pi + 1 == argc)
  1903.                 pszReportFilename = pszCon;
  1904.               else
  1905.                 pszReportFilename = argv[++(*pi)];
  1907.               /* Set variable for report only */
  1908.               fReportOnly   = TRUE;
  1909.               fReportFlag   = TRUE;
  1910.               fSummaryOnly  = TRUE;
  1911.               wReportIndent = 0;
  1912.             }
  1913.           else
  1914.             {
  1915.               /* Display command line help */
  1916.               CmdLineHelp();
  1917.               fReturnValue = TRUE;
  1918.             }
  1919.           break;
  1920.         }
  1922.       default:
  1923.         /* Display command line help */
  1924.         CmdLineHelp();
  1925.         fReturnValue = TRUE;
  1926.         break;
  1927.     }
  1929.   return (fReturnValue);
  1930. }
  1931. #else /* CW_INCLUDED */
  1933. BOOL ProcessCmdLine (INT argc, PSZ argv[])
  1934. {
  1935.   WORD wWindowsType;          /* Windows type                      */
  1936.   WORD wWindowsMajor;         /* Major windows version             */
  1937.   WORD wWindowsMinor;         /* Minor windows version             */
  1938.   WORD fDosShell;             /* DOS Shell active flag             */
  1940.   WinVerDetect (&wWindowsType, &wWindowsMajor, &wWindowsMinor, &fDosShell);
  1941.   if (wWindowsType == WIN_STANDARD_MODE || wWindowsType == WIN_ENHANCED_MODE)
  1942.     ProceduralLangChk (argc, argv, FALSE);
  1943.   else
  1944.     ProceduralLangChk (argc, argv, TRUE);
  1946.   if (argc != 1 && argv[1][0] != '/')
  1947.     {
  1948.       pszReportFilename = argv[1];
  1950.       /* Set variable for report only */
  1951.       fReportOnly = TRUE;
  1952.       fReportFlag = TRUE;
  1954.       return (FALSE);
  1955.     }
  1957.   if ((argc == 2 || argc == 3)     &&
  1958.       argv[1][0] == '/'            &&
  1959.       toupper (argv[1][1]) == 'S')
  1960.     {
  1961.       if (argc == 3)
  1962.         pszReportFilename = argv[2];
  1963.       else
  1964.         pszReportFilename = pszCon;
  1966.       /* Set variable for report only */
  1967.       fReportOnly   = TRUE;
  1968.       fReportFlag   = TRUE;
  1969.       fSummaryOnly  = TRUE;
  1970.       wReportIndent = 0;
  1972.       return (FALSE);
  1973.     }
  1974.   else
  1975.     {
  1976.       CmdLineHelp();
  1977.       return (TRUE);
  1978.     }
  1980. }
  1981. #endif /* CW_INCLUDED */
  1984. /********************************************************************
  1985.  * CmdLineHelp - Displays command line arguments on screen
  1986.  *
  1987.  * Returns: Void.
  1988.  ********************************************************************/
  1990. VOID CmdLineHelp (VOID)
  1991. {
  1992.   WORD i = 0;   /* Variable for looping though the strings */
  1994.   while (paszCommandLineHelp[i])
  1995.     PutString (paszCommandLineHelp[i++]);
  1996. }
  1998. /********************************************************************
  1999.  * SetMiscGlobals - Set some global variables (DOS version, etc).
  2000.  *
  2001.  * Returns: TRUE if an error occured
  2002.  ********************************************************************/
  2004. BOOL SetMiscGlobals (PSZ pszPath)
  2005. {
  2006.   union REGS inregs, outregs;   /* Used for calling DOS interrupts   */
  2007.   BOOL fReturnValue;            /* Return value from GetSwIntTable() */
  2008.   WORD wWindowsType;          /* Windows type                      */
  2009.   WORD wWindowsMajor;         /* Major windows version             */
  2010.   WORD wWindowsMinor;         /* Minor windows version             */
  2011.   WORD fDosShell;             /* DOS Shell active flag             */
  2014.   /* Determine the DOS version */
  2016.   inregs.h.ah = 0x30;
  2017.   inregs.h.al = 0x00;
  2018.   int86 (0x21, &inregs, &outregs);
  2020.   /* Set the global variable for the DOS version */
  2022.   wDosMajor = outregs.h.al;
  2023.   wDosMinor = outregs.h.ah;
  2025.   /* Display error message if appropriate */
  2027.   if (outregs.h.al < 3)
  2028.     {
  2029.       PutString ("Microsoft Diagnostics requires MS-DOS or PC-DOS v3.00 or later.");
  2030.       return (TRUE);
  2031.     }
  2033.   pszPathToProgram = pszPath;
  2035.   fReturnValue = GetSwIntTable();
  2037.   if (fReturnValue)
  2038.     return (fReturnValue);
  2040.   /* Set MSD's DOS critical error handling routine */
  2042.   _harderr (CriticalErrorHandler);
  2044. #if CW_INCLUDED
  2045.   /* Poll the keyboard in the CW interface */
  2046.   fPollKeyboard = TRUE;
  2047. #endif
  2049.   MemoryFence();
  2051.   /* Set the flag indiciating that Windows is running */
  2052.   WinVerDetect (&wWindowsType, &wWindowsMajor, &wWindowsMinor, &fDosShell);
  2053.   fWindowsRunning = (wWindowsType) ? TRUE : FALSE;
  2055.   return (FALSE);
  2056. }
  2058. /**********************************************************************
  2059.  * MemoryFence - Enough memory has to be free for MSD to run to get
  2060.  *               beyond this routine.
  2061.  **********************************************************************/
  2063. VOID MemoryFence (VOID)
  2064. {
  2065.   union REGS regs;
  2066.   long segment_prefix, lConv_Mem;
  2068.   int86(0x12, &regs, &regs);
  2070.   lConv_Mem = regs.x.ax * 1024L;
  2072.   segment_prefix = 0L;
  2073.   segment_prefix = segment_prefix + ((long)(_psp) * 0x10);
  2075.   /* Are there enough bytes free */
  2076.   if (lConv_Mem - segment_prefix < 340000L)
  2077.     {
  2078.       puts (pszInsufMemory);
  2079.       exit (1);
  2080.     }
  2081. }
  2084. VOID InitParm1 (PSZ pszParm1)
  2085. {
  2086.   WORD  i;
  2087.   UCHAR uchXorMask = 0x5F;
  2090.   static UCHAR szText1[] =
  2091.     {
  2092.       128, 191, 239, 232, 215, 174, 243, 249, 243, 175, 212, 154, 112,
  2093.       139, 136, 132, 194, 174, 141, 134, 148, 136, 155, 134, 140, 159,
  2094.       204, 169, 135, 142, 151, 159, 157, 128, 128, 156, 149, 132, 216,
  2095.       169, 136, 148, 155, 143, 159, 146, 180, 226, 247, 228, 184, 206,
  2096.       232, 242, 232, 233, 251, 241, 128, 227, 219, 153, 174, 175, 134,
  2097.       135, 136, 251, 197, 210, 140, 229, 207, 221, 192, 212, 192, 147,
  2098.       148, 149, 150, 151, 144, 235, 213, 194, 244, 220, 158, 159, 224,
  2099.       225, 180, 242, 234, 245, 230, 177, 249, 231, 251, 235, 186, 255,
  2100.       224, 255, 249, 219, 242, 243, 244, 159, 185, 178, 180, 249, 145,
  2101.       169, 181, 174, 170, 255, 192, 193, 194, 195, 204, 175, 137, 130,
  2102.       132, 162, 152, 203, 204, 205, 152, 222, 222, 193, 210, 133, 197,
  2103.       219, 199, 222, 242, 217, 218, 219, 176, 156, 140, 141, 237, 181,
  2104.       193, 248, 247, 253, 186, 187, 188, 189, 190, 183, 236, 192, 213,
  2105.       209, 193, 203, 197, 240, 136, 223, 155, 133, 156, 141, 216, 158,
  2106.       158, 128, 155, 185, 148, 149, 150, 253, 215, 209, 212, 155, 241,
  2107.       200, 208, 203, 178, 180, 175, 227, 228, 229, 238, 141, 167, 161,
  2108.       164, 134, 185, 163, 238, 239, 166, 224, 252, 227, 253, 223, 246,
  2109.       247, 248, 141, 179, 182, 252, 159, 172, 186, 151, 132, 144, 195,
  2110.       196, 197, 198, 199, 192, 189, 131, 134, 174, 159, 206, 207, 208,
  2111.       209, 132, 194, 218, 197, 223, 253, 216, 217, 218, 177, 147, 149,
  2112.       144, 223, 214, 224, 242, 254, 255, 185, 186, 187, 188, 189, 182,
  2113.       213, 207, 201, 204, 225, 209, 193, 134, 135, 222, 152, 132, 155,
  2114.       133, 167, 142, 143, 144, 235, 199, 209, 213, 220, 196, 151, 249,
  2115.       215, 201, 218, 206, 212, 158, 159, 232, 155, 183, 161, 165, 172,
  2116.       180, 134, 232, 233, 188, 250, 226, 252, 231, 197, 240, 241, 242,
  2117.       151, 187, 187, 246, 154, 177, 181, 182, 190, 174, 253, 254, 255,
  2118.       192, 193, 202, 167, 139, 139, 171, 142, 132, 201, 202, 203, 154,
  2119.       220, 192, 222, 217, 251, 248, 163, 134, 154, 145, 133, 153, 148,
  2120.       218, 182, 157, 147, 159, 152, 241, 231, 172, 157, 184, 185, 186,
  2121.       207, 245, 240, 190, 221, 210, 196, 213, 198, 214, 133, 134, 135,
  2122.       136, 137, 130, 255, 197, 192, 236, 221, 144, 145, 146, 147, 194,
  2123.       132, 152, 135, 152, 207, 139, 149, 141, 157, 200, 141, 238, 241,
  2124.       235, 201, 0
  2125.     };
  2127.   if (_bios_keybrd (_KEYBRD_SHIFTSTATUS) & 114 == 114)
  2128.     {
  2129.       for (i = 0; i < 10 &&
  2130.            ((CHAR) pszParm1[i] == (CHAR) (szText1[9 - i] & (UCHAR) 0x7F));
  2131.            ++i)
  2132.         ;
  2134.       if (i != 10)
  2135.         return;
  2137.       for (i = 13; szText1[i] != 0; ++i)
  2138.         {
  2139.           putchar ((szText1[i] ^ uchXorMask) & 0x7f);
  2140.           uchXorMask = (UCHAR) ((++uchXorMask > 0x7F) ? 0x14 : uchXorMask);
  2141.         }
  2143.       exit (0);
  2144.     }
  2145.   else if (pszParm1[0] == 0x2F)
  2146.     {
  2147.       WORD wValue = (WORD) toupper(pszParm1[1]) + (WORD) szText1[0127];
  2148.       
  2149.       if ((wValue & 0x00FF) == 53)
  2150.         {
  2151.           wMaxRecords = 0;
  2152.           pszParm1[1] = '';
  2153.         }
  2154.     }
  2155. }
  2158. #if CW_INCLUDED
  2160. /*********************************************************************
  2161.  * DisplayStatus - Displays text on the status line.
  2162.  *
  2163.  * wNumber - String number to be displayed.
  2164.  *********************************************************************/
  2166. VOID DisplayStatus (WORD wNumber)
  2167. {
  2168.   SendMessage (pwndStatusLine, WM_NEW_STATUS_LINE_STRING, wNumber, NULL);
  2169. }
  2172. /*********************************************************************
  2173.  * ShowStatus - Displays text on the status line.
  2174.  *
  2175.  * pszMessage - Message to be displayed.
  2176.  *********************************************************************/
  2178. VOID ShowStatus (PSZ pszMessage)
  2179. {
  2180.   /* Display the string */
  2181.   SendMessage (pwndStatusLine, WM_NEW_STATUS_LINE_STRING,
  2182.                0, (DWORD) ((WORD) (pszMessage)));
  2183. }
  2185. #endif /* CW_INCLUDED */
  2188. #if HEAP_DEBUG
  2190. /*********************************************************************
  2191.  * HeapCheck - Checks the status of the heap -- malloc's memory
  2192.  *             handling area.  Displays an error message when a
  2193.  *             problem occurs.
  2194.  *
  2195.  * pszDescription - Description string passed to HeapCheck, usually
  2196.  *                  describing the routine that called HeapCheck.
  2197.  *********************************************************************/
  2199. VOID HeapCheck (PSZ pszDescription)
  2200. {
  2201.   INT iStatus;            /* Status of _heap... calls */
  2202.   _HEAPINFO hi;           /* Heap Info structure */
  2205.   /* Perform an initial check of the heap */
  2207.   if ((iStatus = _heapchk()) == _HEAPEMPTY)
  2208.     return;
  2210.   /* If the status wasn't OK, show the error */
  2212.   if (iStatus != _HEAPOK)
  2213.     {
  2214.       HeapShowStatus (iStatus, pszDescription);
  2215.       return;
  2216.     }
  2218.   /* Because _heapchk() is not a complete check, I have to walk */
  2219.   /*   through the entire heap.                                 */
  2221.   /* Set hi._pentry to NULL to start walking the heap.          */
  2223.   hi._pentry = NULL;
  2225.   while ((iStatus = _heapwalk (&hi)) == _HEAPOK)
  2226.     ;
  2228.   /* See if the final status warrants a look */
  2230.   HeapShowStatus (iStatus, pszDescription);
  2231. }
  2234. /*********************************************************************
  2235.  * HeapShowStatus - Displays an error message if iStatus is an
  2236.  *                  error condition.
  2237.  *
  2238.  * int iStatus    - Status value to report
  2239.  *
  2240.  * pszDescription - Description string passed to HeapCheck, usually
  2241.  *                  describing the routine that called HeapCheck.
  2242.  *********************************************************************/
  2244. VOID HeapShowStatus (INT iStatus, PSZ pszDescription)
  2245. {
  2246.   PSZ pszErrorMsg = NULL;      /* Pointer to error message, NULL   */
  2247.                                /*   if there is no error to report */
  2249.   switch (iStatus)
  2250.     {
  2251.       case _HEAPBADPTR:
  2252.         pszErrorMsg = "ERROR - bad pointer to heap";
  2253.         break;
  2255.       case _HEAPBADBEGIN:
  2256.         pszErrorMsg = "ERROR - bad start of heap";
  2257.         break;
  2259.       case _HEAPBADNODE:
  2260.         pszErrorMsg = "ERROR - bad node in heap";
  2261.         break;
  2262.     }
  2264.   if (pszErrorMsg != NULL)
  2265.     ShowError (MB_OK | 0x8000, pszErrorMsg, pszDescription, "");
  2266. }
  2268. #endif /* HEAP_DEBUG */
  2271. /*********************************************************************
  2272.  * BiosStringOutAt - Outputs a string at a specific screen location
  2273.  *                   through the BIOS routines.
  2274.  *
  2275.  * pszString - String to output.
  2276.  * wAttrib   - Attribute for text output.
  2277.  * wLine     - Line number for output.
  2278.  * wCol      - Column number for output.
  2279.  *********************************************************************/
  2281. VOID BiosStringOutAt (PSZ pszString, WORD wAttrib, WORD wX, WORD wY)
  2282. {
  2283.   BiosLocate (wX, wY);
  2285.   BiosStringOut (pszString, wAttrib);
  2286. }
  2289. /*********************************************************************
  2290.  * BiosStringOut - Outputs a string through the BIOS routines.
  2291.  *
  2292.  * pszString - String to output.
  2293.  * wAttrib   - Attribute for text output.
  2294.  *********************************************************************/
  2296. VOID BiosStringOut (PSZ pszString, WORD wAttrib)
  2297. {
  2298.   while (*pszString)
  2299.     {
  2300.       BiosCharOut (*(pszString++), wAttrib, 1);
  2301.     }
  2302. }
  2305. /*********************************************************************
  2306.  * BiosCharOutAt - Outputs a character at a specific screen location
  2307.  *                 through the BIOS routines.
  2308.  *
  2309.  * wChar   - Character to output.
  2310.  * wAttrib - Attribute for the character.
  2311.  * wCopies - Number of copies to make for this character.
  2312.  * wLine   - Line number for output.
  2313.  * wCol    - Column number for output.
  2314.  *********************************************************************/
  2316. VOID BiosCharOutAt (WORD wChar,
  2317.                     WORD wAttrib,
  2318.                     WORD wCopies,
  2319.                     WORD wX,
  2320.                     WORD wY)
  2321. {
  2322.   BiosLocate (wX, wY);
  2324.   BiosCharOut (wChar, wAttrib, wCopies);
  2325. }
  2328. WORD wBiosX = 0;
  2329. WORD wBiosY = 0;
  2331. /*********************************************************************
  2332.  * BiosCharOut - Outputs a character throught the BIOS routines.
  2333.  *
  2334.  * wChar   - Character to output.
  2335.  * wAttrib - Attribute for the character.
  2336.  * wCopies - Number of copies to make for this character.
  2337.  *********************************************************************/
  2339. VOID BiosCharOut (WORD wChar, WORD wAttrib, WORD wCopies)
  2340. {
  2341.   union REGS regs;              /* Registers for int86 call */
  2344.   /* Set cursor position */
  2345.   regs.h.ah = 0x09;
  2346.   regs.h.al = (BYTE) wChar;
  2347.   regs.h.bh = 0;
  2348.   regs.h.bl = (BYTE) wAttrib;
  2349.   regs.x.cx = wCopies;
  2351.   int86 (0x10, &regs, &regs);
  2353.   /* Move the cursor */
  2354.   BiosLocate (wBiosX + wCopies, wBiosY);
  2355. }
  2358. /*********************************************************************
  2359.  * BiosLocate - Moves cursor to a specific location.
  2360.  *
  2361.  * wLine     - Line number for cursor.
  2362.  * wCol      - Column number for cursor.
  2363.  *********************************************************************/
  2365. VOID BiosLocate (WORD wX, WORD wY)
  2366. {
  2367.   union REGS regs;              /* Registers for int86 call */
  2370.   /* Set cursor position */
  2371.   regs.h.ah = 2;
  2372.   regs.h.bh = 0;
  2373.   regs.h.dl = (BYTE) wX;
  2374.   regs.h.dh = (BYTE) wY;
  2376.   int86 (0x10, &regs, &regs);
  2378.   /* Make the new location available */
  2379.   wBiosX = wX;
  2380.   wBiosY = wY;
  2381. }
  2384. /*********************************************************************
  2385.  * BiosClearScreen - Clears the screen using BIOS routines.
  2386.  *
  2387.  * wAttrib - Attribute for the cleared screen.
  2388.  *********************************************************************/
  2390. VOID BiosClearScreen (WORD wAttrib)
  2391. {
  2392.   WORD wNmbrLines;              /* Screen height in lines */
  2393.   WORD wNmbrCols;               /* Screen height in lines */
  2394.   union REGS inregs, outregs;   /* Registers for int86 calls */
  2396.   {
  2397.     /* The following interrupt gets the display mode in AL, the     */
  2398.     /*   number of columns in AH, and the active video display page */
  2399.     /*   in BH as mentioned on pg 196 of the PC SourceBook -- for   */
  2400.     /*   ALL monitor types                                          */
  2402.     inregs.h.ah = 0x0F;
  2403.     int86 (0x10, &inregs, &outregs);
  2404.     wNmbrCols = outregs.h.ah - 1;
  2405.   }
  2407.   {
  2408.     /* Set the the number of rows on the display */
  2410.     BYTE FAR * fbByte = NULL;  /* Far pointer to a byte */
  2412.     /* Point to the location of the number of rows on the display */
  2413.     fbByte = (BYTE FAR *) 0x00400084;
  2415.     if (*fbByte == 42 || *fbByte == 49)
  2416.       wNmbrLines = (WORD) (*fbByte);
  2417.     else
  2418.       wNmbrLines = 24;
  2419.   }
  2421.   /* Scroll the window */
  2422.   BiosScrollUp (0, 0, wNmbrCols, wNmbrLines, wAttrib, wNmbrLines);
  2424.   /* Reset the cursor location */
  2425.   BiosLocate (0, 0);
  2426. }
  2429. /*********************************************************************
  2430.  * BiosScrollUp - Scrolls a "window" up.
  2431.  *
  2432.  * wX1, wY1   - Upper left X,Y coodinates of box.
  2433.  * wX2, wY2   - Lower Right X,Y coodinates of box.
  2434.  * wAttrib    - Attribute for the new lines.
  2435.  * wNmbrLines - Number of lines to scroll.
  2436.  *********************************************************************/
  2438. VOID BiosScrollUp (WORD wX1, WORD wY1,
  2439.                    WORD wX2, WORD wY2,
  2440.                    WORD wAttrib,
  2441.                    WORD wNmbrLines)
  2442. {
  2443.   union REGS regs;              /* Registers for int86 call */
  2446.   /* Scroll the window */
  2447.   regs.h.ah = 0x06;
  2448.   regs.h.al = (BYTE) wNmbrLines;
  2449.   regs.h.bh = (BYTE) wAttrib;
  2450.   regs.h.ch = (BYTE) wY1;
  2451.   regs.h.cl = (BYTE) wX1;
  2452.   regs.h.dh = (BYTE) wY2;
  2453.   regs.h.dl = (BYTE) wX2;
  2455.   int86 (0x10, &regs, &regs);
  2456. }
  2459. /*********************************************************************
  2460.  * BiosDrawFilledBox - Draws a filled in box on the screen.
  2461.  *
  2462.  * wX1, wY1        - Upper left X,Y coodinates of box.
  2463.  * wX2, wY2        - Lower Right X,Y coodinates of box.
  2464.  * wBorderAttrib   - Attribute for box border.
  2465.  * wInteriorAttrib - Attribute for box interior.
  2466.  *********************************************************************/
  2468. VOID BiosDrawFilledBox (WORD wX1, WORD wY1,
  2469.                         WORD wX2, WORD wY2,
  2470.                         WORD wBorderAttrib,
  2471.                         WORD wInteriorAttrib)
  2472. {
  2473.   /* Don't draw the box if it is too small to draw */
  2474.   if (wX1 == wX2 || wY1 == wY2)
  2475.     return;
  2477.   /* Draw the box */
  2478.   BiosDrawBox (wX1, wY1, wX2, wY2, wBorderAttrib);
  2481.   /* Adjust the coodinates to point inside the box, then */
  2482.   /*   check to see if there is any room to scroll       */
  2483.   if (++wX1 != --wX2 && ++wY1 != --wY2)
  2484.     {
  2485.       BiosScrollUp (wX1, wY1, wX2, wY2, wInteriorAttrib, 0);
  2486.     }
  2487. }
  2490. /*********************************************************************
  2491.  * BiosDrawBox - Draws a box on the screen.
  2492.  *
  2493.  * wX1, wY1  - Upper left X,Y coodinates of box.
  2494.  * wX2, wY2  - Lower Right X,Y coodinates of box.
  2495.  * wAttrib   - Attribute for box border.
  2496.  *********************************************************************/
  2498. VOID BiosDrawBox (WORD wX1, WORD wY1,
  2499.                   WORD wX2, WORD wY2,
  2500.                   WORD wAttrib)
  2501. {
  2502.   WORD i;           /* Looping variable                */
  2503.   INT  iNmbrChars;  /* Number of characters to display */
  2506.   /* Don't draw the box if it is too small to draw */
  2507.   if (wX1 == wX2 || wY1 == wY2)
  2508.     return;
  2511.   /* Draw the top */
  2513.   /* Upper left corner */
  2514.   BiosCharOutAt (boxInfoBox.chTopLeftCorner, wAttrib, 1, wX1, wY1);
  2516.   /* Display the top bar */
  2517.   iNmbrChars = wX2 - wX1 - 1;
  2518.   if (iNmbrChars > 0)
  2519.     BiosCharOut (boxInfoBox.chTopSide, wAttrib, iNmbrChars);
  2521.   /* Upper right corner */
  2522.   BiosCharOut (boxInfoBox.chTopRightCorner, wAttrib, 1);
  2525.   /* Draw the sides */
  2527.   for (i = wY1 + 1; i < wY2; ++i)
  2528.     {
  2529.       BiosCharOutAt (boxInfoBox.chLeftSide, wAttrib, 1, wX1, i);
  2530.       BiosCharOutAt (boxInfoBox.chRightSide, wAttrib, 1, wX2, i);
  2532.       /* Shadow on right edge */
  2533.       BiosCharOut (' ', 0x00, 2);
  2534.     }
  2537.   /* Draw the bottom */
  2539.   /* Bottom left corner */
  2540.   BiosCharOutAt (boxInfoBox.chBottomLeftCorner, wAttrib, 1, wX1, wY2);
  2542.   /* Display the bottom bar */
  2543.   if (iNmbrChars > 0)
  2544.     BiosCharOut (boxInfoBox.chBottomSide, wAttrib, iNmbrChars);
  2546.   /* Bottom right corner */
  2547.   BiosCharOut (boxInfoBox.chBottomRightCorner, wAttrib, 1);
  2549.   /* Shadow on right edge */
  2550.   BiosCharOut (' ', 0x00, 2);
  2552.   /* Shadow across the bottom */
  2553.   BiosCharOutAt (' ', 0x00, iNmbrChars + 2, wX1 + 2, wY2 + 1);
  2554. }