Changeset 1335 for trunk/dll/init.c


Ignore:
Timestamp:
Dec 13, 2008, 12:49:02 AM (17 years ago)
Author:
Steven Levine
Message:

Ticket 26: Add exception handlers to all threads using xbeginthread

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/init.c

    r1333 r1335  
    4444  29 Feb 08 GKY Refactor global command line variables to notebook.h
    4545  08 Mar 08 JBS Ticket 230: Replace prefixless INI keys for default directory containers with
    46                 keys using a "DirCnr." prefix
     46                keys using a "DirCnr." prefix
    4747  20 Apr 08 GKY Change default cmd line length to 1024 Ask once if user wants to reset it.
    4848  11 Jul 08 JBS Ticket 230: Simplified code and eliminated some local variables by incorporating
    49                 all the details view settings (both the global variables and those in the
    50                 DIRCNRDATA struct) into a new struct: DETAILS_SETTINGS.
     49                all the details view settings (both the global variables and those in the
     50                DIRCNRDATA struct) into a new struct: DETAILS_SETTINGS.
    5151  16 JUL 08 GKY Use TMP directory for temp files
    5252  17 Jul 08 SHL Reduce code bulk in fUseTmp setup
    … …  
    5454  20 Jul 08 JBS Ticket 114: Support user-selectable env. strings in Tree container.
    5555  20 Jul 08 GKY Add support to delete orphaned tmp directories without deleting tmp of other
    56                 running sessions
     56                running sessions
    5757  23 Aug 08 GKY Check that space on TMP & FM2 save drives exceed 5 GiB; Done to allow user setting of
    58                 minimum size in future
     58                minimum size in future
    5959  29 Nov 08 GKY Remove or replace with a mutex semaphore DosEnterCriSec where appropriate.
    6060  30 Nov 08 GKY Add the option of creating a subdirectory from the arcname
    61                 for the extract path to arc container.
     61                for the extract path to arc container.
     62  10 Dec 08 SHL Integrate exception handler support
    6263
    6364***********************************************************************/
    … …  
    6667#include <string.h>
    6768#include <share.h>
    68 #include <process.h>
     69#include <process.h>                    // getpid
    6970#include <time.h>
    7071#include <ctype.h>
    … …  
    108109#include "autoview.h"                   // AutoViewProc
    109110#include "mainwnd.h"                    // BubbleProc, ChildButtonProc, DriveBackProc,
    110                                         // DriveProc, LEDProc, MainWndProc, StatusProc
    111                                         // ToolBackProc
     111                                        // DriveProc, LEDProc, MainWndProc, StatusProc
     112                                        // ToolBackProc
    112113#include "collect.h"                    // CollectorClientWndProc, CollectorTextProc
    113114#include "getnames.h"                   // CustomFileDlg
    … …  
    134135#include "srchpath.h"                   // searchpath
    135136#include "fortify.h"
     137#include "excputil.h"                   // xbeginthread
    136138
    137139#ifdef __IBMC__
    … …  
    258260    nm = 1;
    259261    rc = DosFindFirst(SwapperDat,
    260                       &hdir,
    261                       FILE_NORMAL | FILE_ARCHIVED |
    262                       FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
    263                       &ffb, sizeof(ffb), &nm, FIL_STANDARDL);
     262                      &hdir,
     263                      FILE_NORMAL | FILE_ARCHIVED |
     264                      FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
     265                      &ffb, sizeof(ffb), &nm, FIL_STANDARDL);
    264266    if (rc && rc != ERROR_FILE_NOT_FOUND && rc != ERROR_PATH_NOT_FOUND) {
    265267      FILEFINDBUF3 ffb;
    266268      rc = DosFindFirst(SwapperDat,
    267                         &hdir,
    268                         FILE_NORMAL | FILE_ARCHIVED |
    269                         FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
    270                         &ffb, sizeof(ffb), &nm, FIL_STANDARD);
     269                        &hdir,
     270                        FILE_NORMAL | FILE_ARCHIVED |
     271                        FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
     272                        &ffb, sizeof(ffb), &nm, FIL_STANDARD);
    271273      fNoLargeFileSupport = TRUE;
    272274    }
    … …  
    275277      fp = fopen(SwapperDat, "r");
    276278      if (fp) {
    277         fclose(fp);
    278         *SwapperDat = 0;
    279         rc = 1;                         // Force config.sys scan
     279        fclose(fp);
     280        *SwapperDat = 0;
     281        rc = 1;                         // Force config.sys scan
    280282      }
    281283    }
    … …  
    286288  if (rc) {
    287289    if (DosQuerySysInfo(QSV_BOOT_DRIVE,
    288                         QSV_BOOT_DRIVE,
    289                         &nm,
    290                         sizeof(ULONG))) {
     290                        QSV_BOOT_DRIVE,
     291                        &nm,
     292                        sizeof(ULONG))) {
    291293      nm = 3;                           // Assume drive C:
    292294    }
    … …  
    295297    if (fp) {
    296298      while (!feof(fp)) {
    297         if (!xfgets(input, sizeof(input), fp, pszSrcFile, __LINE__))
    298           break;
    299         lstrip(input);
    300         if (!strnicmp(input, "SWAPPATH", 8)) {
    301           p = input + 8;
    302           while (*p == ' ')
    303             p++;
    304           if (*p == '=') {
    305             p++;
    306             stripcr(p);
    307             rstrip(p);
    308             while (*p == ' ')
    309               p++;
    310             if (*p == '\"') {
    311               p++;
    312               pp = p;
    313               while (*pp && *pp != '\"')
    314                 *pp += 1;
    315               if (*pp)
    316                 *pp = 0;
    317             }
    318             else {
    319               pp = strchr(p, ' ');
    320               if (pp)
    321                 *pp = 0;
    322             }
    323             if (*p) {
    324               strncpy(SwapperDat, p, CCHMAXPATH);
    325               SwapperDat[CCHMAXPATH - 1] = 0;
    326               BldFullPathName(SwapperDat, SwapperDat, "SWAPPER.DAT");
    327               hdir = HDIR_CREATE;
    328               nm = 1;
    329               rc = DosFindFirst(SwapperDat,
    330                                 &hdir,
    331                                 FILE_NORMAL | FILE_ARCHIVED |
    332                                 FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
    333                                 &ffb, sizeof(ffb), &nm, FIL_STANDARD);
    334               if (rc){
    335                 FILEFINDBUF3 ffb;
    336                 rc = DosFindFirst(SwapperDat,
    337                                   &hdir,
    338                                   FILE_NORMAL | FILE_ARCHIVED |
    339                                   FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
    340                                   &ffb, sizeof(ffb), &nm, FIL_STANDARD);
    341                 fNoLargeFileSupport = TRUE;
    342               }
    343               if (!rc) {
    344                 DosFindClose(hdir);
    345                 PrfWriteProfileString(fmprof,
    346                                       FM3Str, "SwapperDat", SwapperDat);
    347               }
    348               else
    349                 *SwapperDat = 0;
    350               break;
    351             }
    352           }
    353         }                               // if SWAPPATH
     299        if (!xfgets(input, sizeof(input), fp, pszSrcFile, __LINE__))
     300          break;
     301        lstrip(input);
     302        if (!strnicmp(input, "SWAPPATH", 8)) {
     303          p = input + 8;
     304          while (*p == ' ')
     305            p++;
     306          if (*p == '=') {
     307            p++;
     308            stripcr(p);
     309            rstrip(p);
     310            while (*p == ' ')
     311              p++;
     312            if (*p == '\"') {
     313              p++;
     314              pp = p;
     315              while (*pp && *pp != '\"')
     316                *pp += 1;
     317              if (*pp)
     318                *pp = 0;
     319            }
     320            else {
     321              pp = strchr(p, ' ');
     322              if (pp)
     323                *pp = 0;
     324            }
     325            if (*p) {
     326              strncpy(SwapperDat, p, CCHMAXPATH);
     327              SwapperDat[CCHMAXPATH - 1] = 0;
     328              BldFullPathName(SwapperDat, SwapperDat, "SWAPPER.DAT");
     329              hdir = HDIR_CREATE;
     330              nm = 1;
     331              rc = DosFindFirst(SwapperDat,
     332                                &hdir,
     333                                FILE_NORMAL | FILE_ARCHIVED |
     334                                FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
     335                                &ffb, sizeof(ffb), &nm, FIL_STANDARD);
     336              if (rc){
     337                FILEFINDBUF3 ffb;
     338                rc = DosFindFirst(SwapperDat,
     339                                  &hdir,
     340                                  FILE_NORMAL | FILE_ARCHIVED |
     341                                  FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
     342                                  &ffb, sizeof(ffb), &nm, FIL_STANDARD);
     343                fNoLargeFileSupport = TRUE;
     344              }
     345              if (!rc) {
     346                DosFindClose(hdir);
     347                PrfWriteProfileString(fmprof,
     348                                      FM3Str, "SwapperDat", SwapperDat);
     349              }
     350              else
     351                *SwapperDat = 0;
     352              break;
     353            }
     354          }
     355        }                               // if SWAPPATH
    354356      }                                 // while
    355357      fclose(fp);
    … …  
    361363
    362364unsigned APIENTRY LibMain(unsigned hModule,
    363                           unsigned ulFlag)
     365                          unsigned ulFlag)
    364366{
    365367  CHAR *env;
    … …  
    380382      rc = DosQueryPathInfo(env, FIL_STANDARD, &fsa, sizeof(fsa));
    381383      if (!rc) {
    382         if (fsa.attrFile & FILE_DIRECTORY) {
    383           BldFullPathName(stringfile, env, "FM3RES.STR");
    384           DosError(FERR_DISABLEHARDERR);
    385           if (DosQueryPathInfo(stringfile, FIL_STANDARD, &fsa, sizeof(fsa)))
    386             strcpy(stringfile, "FM3RES.STR");
    387         }
     384        if (fsa.attrFile & FILE_DIRECTORY) {
     385          BldFullPathName(stringfile, env, "FM3RES.STR");
     386          DosError(FERR_DISABLEHARDERR);
     387          if (DosQueryPathInfo(stringfile, FIL_STANDARD, &fsa, sizeof(fsa)))
     388            strcpy(stringfile, "FM3RES.STR");
     389        }
    388390      }
    389391    }
    … …  
    475477
    476478unsigned long _System _DLL_InitTerm(unsigned long hModule,
    477                                     unsigned long ulFlag)
     479                                    unsigned long ulFlag)
    478480{
    479481  CHAR *env;
    … …  
    493495      rc = DosQueryPathInfo(env, FIL_STANDARD, &fsa, sizeof(fsa));
    494496      if (!rc) {
    495         if (fsa.attrFile & FILE_DIRECTORY) {
    496           BldFullPathName(stringfile, env, "FM3RES.STR");
    497           DosError(FERR_DISABLEHARDERR);
    498           if (DosQueryPathInfo(stringfile, FIL_STANDARD, &fsa, sizeof(fsa)))
    499             strcpy(stringfile, "FM3RES.STR");
    500         }
     497        if (fsa.attrFile & FILE_DIRECTORY) {
     498          BldFullPathName(stringfile, env, "FM3RES.STR");
     499          DosError(FERR_DISABLEHARDERR);
     500          if (DosQueryPathInfo(stringfile, FIL_STANDARD, &fsa, sizeof(fsa)))
     501            strcpy(stringfile, "FM3RES.STR");
     502        }
    501503      }
    502504    }
    … …  
    629631    num_matches = 1L;
    630632    if (!DosFindFirst(s,
    631                       &search_handle,
    632                       FILE_NORMAL | FILE_DIRECTORY |
    633                       FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN |
    634                       FILE_ARCHIVED,
    635                       &ffb, sizeof(ffb), &num_matches, FIL_STANDARD)) {
     633                      &search_handle,
     634                      FILE_NORMAL | FILE_DIRECTORY |
     635                      FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN |
     636                      FILE_ARCHIVED,
     637                      &ffb, sizeof(ffb), &num_matches, FIL_STANDARD)) {
    636638      do {
    637         strcpy(enddir, ffb.achName);
    638         if (ffb.attrFile & FILE_DIRECTORY) {
    639           wipeallf("%s\\*", s);
    640           DosDeleteDir(s);
    641         }
    642         else
    643           unlinkf("%s", s);
     639        strcpy(enddir, ffb.achName);
     640        if (ffb.attrFile & FILE_DIRECTORY) {
     641          wipeallf("%s\\*", s);
     642          DosDeleteDir(s);
     643        }
     644        else
     645          unlinkf("%s", s);
    644646      }
    645647      while (!DosFindNext(search_handle,
    646                           &ffb, sizeof(ffb), &num_matches));
     648                          &ffb, sizeof(ffb), &num_matches));
    647649      DosFindClose(search_handle);
    648650    }
    … …  
    660662  num_matches = 1;
    661663  if (!DosFindFirst(s,
    662                     &search_handle,
    663                     FILE_NORMAL | FILE_DIRECTORY |
    664                     FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN |
    665                     FILE_ARCHIVED,
    666                     &ffb, sizeof(ffb), &num_matches, FIL_STANDARD)) {
     664                    &search_handle,
     665                    FILE_NORMAL | FILE_DIRECTORY |
     666                    FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN |
     667                    FILE_ARCHIVED,
     668                    &ffb, sizeof(ffb), &num_matches, FIL_STANDARD)) {
    667669    do {
    668670      if (!(ffb.attrFile & FILE_DIRECTORY)) {
    669         strcpy(enddir, ffb.achName);
    670         unlinkf("%s", s);
     671        strcpy(enddir, ffb.achName);
     672        unlinkf("%s", s);
    671673      }
    672674    }
    673675    while (!DosFindNext(search_handle,
    674                         &ffb, sizeof(ffb), &num_matches));
     676                        &ffb, sizeof(ffb), &num_matches));
    675677    DosFindClose(search_handle);
    676678  }
    … …  
    710712  if (!StringsLoaded()) {
    711713    saymsg(MB_ENTER,
    712            HWND_DESKTOP,
    713            "Error",
    714            "FM3RES.STR isn't in right format, at least "
    715            "for this version of FM/2.");
     714           HWND_DESKTOP,
     715           "Error",
     716           "FM3RES.STR isn't in right format, at least "
     717           "for this version of FM/2.");
    716718    return FALSE;
    717719  }
    … …  
    724726    if (!rc) {
    725727      if (fs3.attrFile & FILE_DIRECTORY) {
    726         BldFullPathName(dllfile, env, "FM3RES");        // 23 Aug 07 SHL
    727         DosError(FERR_DISABLEHARDERR);
    728         if (DosQueryPathInfo(dllfile, FIL_STANDARD, &fs3, sizeof(fs3)))
    729           strcpy(dllfile, "FM3RES");
     728        BldFullPathName(dllfile, env, "FM3RES");        // 23 Aug 07 SHL
     729        DosError(FERR_DISABLEHARDERR);
     730        if (DosQueryPathInfo(dllfile, FIL_STANDARD, &fs3, sizeof(fs3)))
     731          strcpy(dllfile, "FM3RES");
    730732      }
    731733    }
    … …  
    734736  if (rcl) {
    735737    saymsg(MB_CANCEL | MB_ICONEXCLAMATION,
    736            HWND_DESKTOP,
    737            GetPString(IDS_ERRORTEXT), GetPString(IDS_FM3RESERROR1TEXT));
     738           HWND_DESKTOP,
     739           GetPString(IDS_ERRORTEXT), GetPString(IDS_FM3RESERROR1TEXT));
    738740    return FALSE;
    739741  }
    … …  
    742744    if (rc) {
    743745      Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
    744                "DosExitList");
     746               "DosExitList");
    745747    }
    746748    rcq = DosQueryProcAddr(FM3ModHandle, 1, "ResVersion", &pfnResVersion);
    … …  
    750752  if (RVMajor < VERMAJOR || (RVMajor == VERMAJOR && RVMinor < VERMINOR)) {
    751753    saymsg(MB_ENTER,
    752            HWND_DESKTOP,
    753            GetPString(IDS_ERRORTEXT),
    754            GetPString(IDS_FM3RESERROR2TEXT),
    755            !rcq ?
    756            GetPString(IDS_FM3RESERROR3TEXT) :
    757            !rcl ?
    758            GetPString(IDS_FM3RESERROR4TEXT) :
    759            GetPString(IDS_FM3RESERROR5TEXT), RVMajor, RVMinor, rcl, rcq, ret);
     754           HWND_DESKTOP,
     755           GetPString(IDS_ERRORTEXT),
     756           GetPString(IDS_FM3RESERROR2TEXT),
     757           !rcq ?
     758           GetPString(IDS_FM3RESERROR3TEXT) :
     759           !rcl ?
     760           GetPString(IDS_FM3RESERROR4TEXT) :
     761           GetPString(IDS_FM3RESERROR5TEXT), RVMajor, RVMinor, rcl, rcq, ret);
    760762    return FALSE;
    761763  }
    … …  
    775777    DosSetMaxFH(100);
    776778  else if (!strcmp(appname, "VDir") ||
    777            !strcmp(appname, "VTree") ||
    778            !strcmp(appname, "VCollect") ||
    779            !strcmp(appname, "SEEALL") || !strcmp(appname, "FM/4"))
     779           !strcmp(appname, "VTree") ||
     780           !strcmp(appname, "VCollect") ||
     781           !strcmp(appname, "SEEALL") || !strcmp(appname, "FM/4"))
    780782    DosSetMaxFH(60);
    781783  else
    … …  
    783785
    784786  if (DosQuerySysInfo(QSV_VERSION_MAJOR,
    785                       QSV_VERSION_MINOR,
    786                       OS2ver,
    787                       sizeof(OS2ver))) {
     787                      QSV_VERSION_MINOR,
     788                      OS2ver,
     789                      sizeof(OS2ver))) {
    788790    OS2ver[0] = 2;
    789791    OS2ver[1] = 1;
    … …  
    805807      strcpy(szTempName, env);
    806808      if (szTempName[strlen(szTempName) - 1] != '\\')
    807         strcat(szTempName, "\\");
     809        strcat(szTempName, "\\");
    808810      enddir = &szTempName[strlen(szTempName)];
    809811      strcat(szTempName, "$FM2????.");
    … …  
    812814      num_matches = 1;
    813815      if (!DosFindFirst(szTempName,
    814                         &search_handle,
    815                         FILE_NORMAL | FILE_DIRECTORY |
    816                         FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN |
    817                         FILE_ARCHIVED,
    818                         &ffb, sizeof(ffb), &num_matches, FIL_STANDARD)) {
    819         do {
    820           strcpy(enddir, ffb.achName);
    821           p = strrchr(szTempName, '.');
    822           if (p) {
    823             p++;
    824             ul = strtol(p, &p + 2, 16);
    825             GetDosPgmName(ul, temp);
    826             if (!strstr(temp, "FM/2") &&
    827                 !strstr(temp, "AV/2")) {
    828               wipeallf("%s\\*", szTempName);
    829               DosDeleteDir(szTempName);
    830             }
    831           }
    832         }
     816                        &search_handle,
     817                        FILE_NORMAL | FILE_DIRECTORY |
     818                        FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN |
     819                        FILE_ARCHIVED,
     820                        &ffb, sizeof(ffb), &num_matches, FIL_STANDARD)) {
     821        do {
     822          strcpy(enddir, ffb.achName);
     823          p = strrchr(szTempName, '.');
     824          if (p) {
     825            p++;
     826            ul = strtol(p, &p + 2, 16);
     827            GetDosPgmName(ul, temp);
     828            if (!strstr(temp, "FM/2") &&
     829                !strstr(temp, "AV/2")) {
     830              wipeallf("%s\\*", szTempName);
     831              DosDeleteDir(szTempName);
     832            }
     833          }
     834        }
    833835      while (!DosFindNext(search_handle,
    834                           &ffb, sizeof(ffb), &num_matches));
     836                          &ffb, sizeof(ffb), &num_matches));
    835837      DosFindClose(search_handle);
    836838    }
    837839      if (fs3.attrFile & FILE_DIRECTORY) {
    838         APIRET ret = 0;
    839         strcpy(szTempName, env);
    840         MakeTempName(szTempName, NULL, 1);
    841         ret = DosCreateDir(szTempName, 0);
    842         if (!ret) {   //check writable
    843           pTmpDir = xstrdup(szTempName, pszSrcFile, __LINE__);
    844         }
     840        APIRET ret = 0;
     841        strcpy(szTempName, env);
     842        MakeTempName(szTempName, NULL, 1);
     843        ret = DosCreateDir(szTempName, 0);
     844        if (!ret) {   //check writable
     845          pTmpDir = xstrdup(szTempName, pszSrcFile, __LINE__);
     846        }
    845847      }
    846848    }
    … …  
    858860    if (pTmpDir && CheckDriveSpaceAvail(pTmpDir, ullTmpSpaceNeeded, 0) == 1) {
    859861      if (CheckDriveSpaceAvail(pFM2SaveDirectory, ullTmpSpaceNeeded, 0) == 0){
    860         ret = saymsg(MB_YESNO,
    861                      HWND_DESKTOP,
    862                      NullStr,
    863                      GetPString(IDS_TMPDRIVESPACELIMITED),
    864                      pTmpDir);
    865         if (ret == MBID_YES)
    866           pTmpDir = pFM2SaveDirectory;
     862        ret = saymsg(MB_YESNO,
     863                     HWND_DESKTOP,
     864                     NullStr,
     865                     GetPString(IDS_TMPDRIVESPACELIMITED),
     866                     pTmpDir);
     867        if (ret == MBID_YES)
     868          pTmpDir = pFM2SaveDirectory;
    867869      }
    868870      else
    869         saymsg(MB_OK,
    870                HWND_DESKTOP,
    871                NullStr,
    872                GetPString(IDS_SAVETMPDRIVESPACELIMITED),
    873                pTmpDir,
    874                pFM2SaveDirectory);
     871        saymsg(MB_OK,
     872               HWND_DESKTOP,
     873               NullStr,
     874               GetPString(IDS_SAVETMPDRIVESPACELIMITED),
     875               pTmpDir,
     876               pFM2SaveDirectory);
    875877    }
    876878    else if (CheckDriveSpaceAvail(pFM2SaveDirectory, ullTmpSpaceNeeded, 0) == 1)
    877879      saymsg(MB_OK,
    878              HWND_DESKTOP,
    879              NullStr,
    880              GetPString(IDS_SAVEDRIVESPACELIMITED),
    881              pFM2SaveDirectory);
     880             HWND_DESKTOP,
     881             NullStr,
     882             GetPString(IDS_SAVEDRIVESPACELIMITED),
     883             pFM2SaveDirectory);
    882884  }
    883885  BldFullPathName(ArcTempRoot, pTmpDir, fAmAV2 ? "$AV$ARC$" : "$FM$ARC$");
    … …  
    889891
    890892  /* _heapmin() is done in a separate thread -- start it */
    891   if (_beginthread(HeapThread, NULL, 32768, NULL) == -1) {
    892     Runtime_Error(pszSrcFile, __LINE__,
    893                   GetPString(IDS_COULDNTSTARTTHREADTEXT));
     893  if (xbeginthread(HeapThread,
     894                   32768,
     895                   MPVOID,
     896                   pszSrcFile,
     897                   __LINE__) == -1) {
    894898    return FALSE;
    895899  }
    … …  
    898902  if (!StartTimer()) {
    899903    Runtime_Error(pszSrcFile, __LINE__,
    900                   GetPString(IDS_COULDNTSTARTTHREADTEXT));
     904                  GetPString(IDS_COULDNTSTARTTHREADTEXT));
    901905    return FALSE;
    902906  }
    … …  
    905909  env = getenv("WORKPLACE_PROCESS");
    906910  fWorkPlace = env != NULL &&
    907                (stricmp(env, "YES") == 0 || atoi(env) == 1);
     911               (stricmp(env, "YES") == 0 || atoi(env) == 1);
    908912
    909913  if ((!strchr(profile, '\\') && !strchr(profile, ':')) ||
    … …  
    924928      rc = DosQueryPathInfo(inipath, FIL_STANDARD, &fs3, sizeof(fs3));
    925929      if (!rc) {
    926         if (fs3.attrFile & FILE_DIRECTORY)
    927           BldFullPathName(inipath, inipath, profile);
     930        if (fs3.attrFile & FILE_DIRECTORY)
     931          BldFullPathName(inipath, inipath, profile);
    928932      }
    929933    }
    … …  
    931935      env = searchpath(profile);
    932936      if (!env)
    933         env = profile;
     937        env = profile;
    934938      strcpy(inipath, env);
    935939    }
    … …  
    948952    else {
    949953      if (!CheckFileHeader(inipath, "\xff\xff\xff\xff\x14\x00\x00\x00", 0L)) {
    950         saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,
    951                "Check INI header failed will attempt to replace with backup \\
    952                if backup fails or not found will open with new ini");
    953         DosCopy("FM3.INI", "FM3INI.BAD", DCPY_EXISTING);
    954         DosCopy("FM3INI.BAK", "FM3.INI", DCPY_EXISTING);
    955         if (!CheckFileHeader(inipath, "\xff\xff\xff\xff\x14\x00\x00\x00", 0L)) {
    956           DosCopy("FM3.INI", "FM3INI2.BAD", DCPY_EXISTING);
    957           fWantFirstTimeInit = TRUE;
    958         }
     954        saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,
     955               "Check INI header failed will attempt to replace with backup \\
     956               if backup fails or not found will open with new ini");
     957        DosCopy("FM3.INI", "FM3INI.BAD", DCPY_EXISTING);
     958        DosCopy("FM3INI.BAK", "FM3.INI", DCPY_EXISTING);
     959        if (!CheckFileHeader(inipath, "\xff\xff\xff\xff\x14\x00\x00\x00", 0L)) {
     960          DosCopy("FM3.INI", "FM3INI2.BAD", DCPY_EXISTING);
     961          fWantFirstTimeInit = TRUE;
     962        }
    959963      }
    960964      if (!fWantFirstTimeInit) {
    961         fIniExisted = TRUE;
    962         if (fs3.attrFile & (FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM)) {
    963           fs3.attrFile &= ~(FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM);
    964           rc = xDosSetPathInfo(inipath, FIL_STANDARD, &fs3, sizeof(fs3), 0);
    965           if (rc) {
    966             Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
    967                         GetPString(IDS_INIREADONLYTEXT), inipath);
    968           }
    969         }
     965        fIniExisted = TRUE;
     966        if (fs3.attrFile & (FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM)) {
     967          fs3.attrFile &= ~(FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM);
     968          rc = xDosSetPathInfo(inipath, FIL_STANDARD, &fs3, sizeof(fs3), 0);
     969          if (rc) {
     970            Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
     971                        GetPString(IDS_INIREADONLYTEXT), inipath);
     972          }
     973        }
    970974      }
    971975    }
    … …  
    980984    if (!fmprof) {
    981985      Win_Error(NULLHANDLE, NULLHANDLE, pszSrcFile, __LINE__,
    982                 "PrfOpenProfile");
     986                "PrfOpenProfile");
    983987      return FALSE;
    984988    }
    … …  
    989993  size = sizeof(BOOL);
    990994  PrfQueryProfileData(fmprof,
    991                       FM3Str,
    992                       "SeparateParms",
    993                       &fSeparateParms,
    994                       &size);
     995                      FM3Str,
     996                      "SeparateParms",
     997                      &fSeparateParms,
     998                      &size);
    995999  if (!fSeparateParms)
    9961000    strcpy(appname, FM3Str);
    … …  
    10181022      rc = DosQueryPathInfo(helppath, FIL_STANDARD, &fs3, sizeof(fs3));
    10191023      if (!rc) {
    1020         if (fs3.attrFile & FILE_DIRECTORY) {
    1021           BldFullPathName(helppath, helppath, "FM3.HLP");
    1022           hini.pszHelpLibraryName = helppath;
    1023           hwndHelp = WinCreateHelpInstance(hab, &hini);
    1024         }
     1024        if (fs3.attrFile & FILE_DIRECTORY) {
     1025          BldFullPathName(helppath, helppath, "FM3.HLP");
     1026          hini.pszHelpLibraryName = helppath;
     1027          hwndHelp = WinCreateHelpInstance(hab, &hini);
     1028        }
    10251029      }
    10261030    }
    … …  
    10281032  if (!hwndHelp) {
    10291033    saymsg(MB_ENTER | MB_ICONEXCLAMATION,
    1030            HWND_DESKTOP,
    1031            GetPString(IDS_FM2TROUBLETEXT),
    1032            GetPString(IDS_CANTLOADHELPTEXT),
    1033            GetPString(IDS_NOHELPACCEPTTEXT));
     1034           HWND_DESKTOP,
     1035           GetPString(IDS_FM2TROUBLETEXT),
     1036           GetPString(IDS_CANTLOADHELPTEXT),
     1037           GetPString(IDS_NOHELPACCEPTTEXT));
    10341038  }
    10351039
    … …  
    10571061  /* register window classes we use */
    10581062  WinRegisterClass(hab,
    1059                    WC_MAINWND,
    1060                    MainWndProc,
    1061                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 8);
    1062   WinRegisterClass(hab,
    1063                    WC_MAINWND2,
    1064                    MainWndProc2,
    1065                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 4);
    1066   WinRegisterClass(hab,
    1067                    WC_TREECONTAINER,
    1068                    TreeClientWndProc,
    1069                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
    1070   WinRegisterClass(hab,
    1071                    WC_DIRCONTAINER,
    1072                    DirClientWndProc,
    1073                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
    1074   WinRegisterClass(hab,
    1075                    WC_COLLECTOR,
    1076                    CollectorClientWndProc,
    1077                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
    1078   WinRegisterClass(hab,
    1079                    WC_ARCCONTAINER,
    1080                    ArcClientWndProc,
    1081                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
    1082   WinRegisterClass(hab,
    1083                    WC_MLEEDITOR,
    1084                    MLEEditorProc,
    1085                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
    1086   WinRegisterClass(hab,
    1087                    WC_INIEDITOR,
    1088                    IniProc,
    1089                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
    1090   WinRegisterClass(hab,
    1091                    WC_TOOLBACK,
    1092                    ToolBackProc,
    1093                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1094                    sizeof(PVOID));
    1095   WinRegisterClass(hab,
    1096                    WC_DRIVEBACK,
    1097                    DriveBackProc,
    1098                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1099                    sizeof(PVOID));
    1100   WinRegisterClass(hab,
    1101                    WC_SEEALL,
    1102                    SeeAllWndProc,
    1103                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID));
    1104   WinRegisterClass(hab,
    1105                    WC_NEWVIEW,
    1106                    ViewWndProc,
    1107                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID));
    1108   WinRegisterClass(hab,
    1109                    WC_TOOLBUTTONS,
    1110                    ChildButtonProc,
    1111                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1112                    sizeof(PVOID));
    1113   WinRegisterClass(hab,
    1114                    WC_DRIVEBUTTONS,
    1115                    DriveProc,
    1116                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1117                    sizeof(PVOID));
    1118   WinRegisterClass(hab,
    1119                    WC_BUBBLE,
    1120                    BubbleProc,
    1121                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1122                    sizeof(ULONG) * 2);
    1123   WinRegisterClass(hab,
    1124                    WC_STATUS,
    1125                    StatusProc,
    1126                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1127                    sizeof(ULONG));
    1128   WinRegisterClass(hab,
    1129                    WC_DIRSTATUS,
    1130                    DirTextProc,
    1131                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1132                    sizeof(ULONG));
    1133   WinRegisterClass(hab,
    1134                    WC_TREESTATUS,
    1135                    TreeStatProc,
    1136                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1137                    sizeof(ULONG));
    1138   WinRegisterClass(hab,
    1139                    WC_ARCSTATUS,
    1140                    ArcTextProc,
    1141                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1142                    sizeof(ULONG));
    1143   WinRegisterClass(hab,
    1144                    WC_COLSTATUS,
    1145                    CollectorTextProc,
    1146                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1147                    sizeof(ULONG));
    1148   WinRegisterClass(hab,
    1149                    WC_SEESTATUS,
    1150                    SeeStatusProc,
    1151                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1152                    sizeof(ULONG));
    1153   WinRegisterClass(hab,
    1154                    WC_VIEWSTATUS,
    1155                    ViewStatusProc,
    1156                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1157                    sizeof(ULONG));
    1158   WinRegisterClass(hab,
    1159                    WC_ERRORWND,
    1160                    NotifyWndProc,
    1161                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1162                    sizeof(PVOID));
    1163   WinRegisterClass(hab,
    1164                    WC_MINITIME,
    1165                    MiniTimeProc,
    1166                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1167                    sizeof(PVOID) * 2);
    1168   WinRegisterClass(hab,
    1169                    WC_DATABAR,
    1170                    DataProc, CS_SIZEREDRAW, sizeof(PVOID));
    1171   WinRegisterClass(hab,
    1172                    WC_TREEOPENBUTTON,
    1173                    OpenButtonProc,
    1174                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1175                    sizeof(PVOID));
    1176   WinRegisterClass(hab,
    1177                    WC_AUTOVIEW,
    1178                    AutoViewProc,
    1179                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1180                    sizeof(PVOID));
    1181   WinRegisterClass(hab,
    1182                    WC_LED,
    1183                    LEDProc,
    1184                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1185                    sizeof(PVOID));
     1063                   WC_MAINWND,
     1064                   MainWndProc,
     1065                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 8);
     1066  WinRegisterClass(hab,
     1067                   WC_MAINWND2,
     1068                   MainWndProc2,
     1069                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 4);
     1070  WinRegisterClass(hab,
     1071                   WC_TREECONTAINER,
     1072                   TreeClientWndProc,
     1073                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
     1074  WinRegisterClass(hab,
     1075                   WC_DIRCONTAINER,
     1076                   DirClientWndProc,
     1077                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
     1078  WinRegisterClass(hab,
     1079                   WC_COLLECTOR,
     1080                   CollectorClientWndProc,
     1081                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
     1082  WinRegisterClass(hab,
     1083                   WC_ARCCONTAINER,
     1084                   ArcClientWndProc,
     1085                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
     1086  WinRegisterClass(hab,
     1087                   WC_MLEEDITOR,
     1088                   MLEEditorProc,
     1089                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
     1090  WinRegisterClass(hab,
     1091                   WC_INIEDITOR,
     1092                   IniProc,
     1093                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
     1094  WinRegisterClass(hab,
     1095                   WC_TOOLBACK,
     1096                   ToolBackProc,
     1097                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1098                   sizeof(PVOID));
     1099  WinRegisterClass(hab,
     1100                   WC_DRIVEBACK,
     1101                   DriveBackProc,
     1102                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1103                   sizeof(PVOID));
     1104  WinRegisterClass(hab,
     1105                   WC_SEEALL,
     1106                   SeeAllWndProc,
     1107                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID));
     1108  WinRegisterClass(hab,
     1109                   WC_NEWVIEW,
     1110                   ViewWndProc,
     1111                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID));
     1112  WinRegisterClass(hab,
     1113                   WC_TOOLBUTTONS,
     1114                   ChildButtonProc,
     1115                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1116                   sizeof(PVOID));
     1117  WinRegisterClass(hab,
     1118                   WC_DRIVEBUTTONS,
     1119                   DriveProc,
     1120                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1121                   sizeof(PVOID));
     1122  WinRegisterClass(hab,
     1123                   WC_BUBBLE,
     1124                   BubbleProc,
     1125                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1126                   sizeof(ULONG) * 2);
     1127  WinRegisterClass(hab,
     1128                   WC_STATUS,
     1129                   StatusProc,
     1130                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1131                   sizeof(ULONG));
     1132  WinRegisterClass(hab,
     1133                   WC_DIRSTATUS,
     1134                   DirTextProc,
     1135                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1136                   sizeof(ULONG));
     1137  WinRegisterClass(hab,
     1138                   WC_TREESTATUS,
     1139                   TreeStatProc,
     1140                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1141                   sizeof(ULONG));
     1142  WinRegisterClass(hab,
     1143                   WC_ARCSTATUS,
     1144                   ArcTextProc,
     1145                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1146                   sizeof(ULONG));
     1147  WinRegisterClass(hab,
     1148                   WC_COLSTATUS,
     1149                   CollectorTextProc,
     1150                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1151                   sizeof(ULONG));
     1152  WinRegisterClass(hab,
     1153                   WC_SEESTATUS,
     1154                   SeeStatusProc,
     1155                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1156                   sizeof(ULONG));
     1157  WinRegisterClass(hab,
     1158                   WC_VIEWSTATUS,
     1159                   ViewStatusProc,
     1160                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1161                   sizeof(ULONG));
     1162  WinRegisterClass(hab,
     1163                   WC_ERRORWND,
     1164                   NotifyWndProc,
     1165                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1166                   sizeof(PVOID));
     1167  WinRegisterClass(hab,
     1168                   WC_MINITIME,
     1169                   MiniTimeProc,
     1170                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1171                   sizeof(PVOID) * 2);
     1172  WinRegisterClass(hab,
     1173                   WC_DATABAR,
     1174                   DataProc, CS_SIZEREDRAW, sizeof(PVOID));
     1175  WinRegisterClass(hab,
     1176                   WC_TREEOPENBUTTON,
     1177                   OpenButtonProc,
     1178                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1179                   sizeof(PVOID));
     1180  WinRegisterClass(hab,
     1181                   WC_AUTOVIEW,
     1182                   AutoViewProc,
     1183                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1184                   sizeof(PVOID));
     1185  WinRegisterClass(hab,
     1186                   WC_LED,
     1187                   LEDProc,
     1188                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1189                   sizeof(PVOID));
    11861190
    11871191  if (DosCreateMutexSem(NULL, &hmtxFM2Globals, 0L, FALSE))
    11881192    Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
    1189               "DosCreateMutexSem");
     1193              "DosCreateMutexSem");
    11901194  if (DosCreateMutexSem(NULL, &hmtxFM2Delete, 0L, FALSE))
    11911195    Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
    1192               "DosCreateMutexSem");
     1196              "DosCreateMutexSem");
    11931197
    11941198  /*
    … …  
    12291233
    12301234  DosQueryCtryInfo(sizeof(CtryInfo), &Country,
    1231                    &CtryInfo, &ulInfoLen);
     1235                   &CtryInfo, &ulInfoLen);
    12321236  *ThousandsSeparator = CtryInfo.szThousandsSeparator[0];
    12331237  }
    … …  
    12441248    if (!MaxComLineChecked) {
    12451249      ret = saymsg(MB_YESNO,
    1246                    HWND_DESKTOP,
    1247                    NullStr,
    1248                    GetPString(IDS_CHANGECMDLINELENGTHDEFAULT));
     1250                   HWND_DESKTOP,
     1251                   NullStr,
     1252                   GetPString(IDS_CHANGECMDLINELENGTHDEFAULT));
    12491253      if (ret == MBID_YES)
    1250         MaxComLineStrg = 1024;
     1254        MaxComLineStrg = 1024;
    12511255      MaxComLineChecked = TRUE;
    12521256      PrfWriteProfileData(fmprof, appname, "MaxComLineChecked", &MaxComLineChecked, sizeof(BOOL));
    … …  
    13551359  size = sizeof(ULONG);
    13561360  PrfQueryProfileData(fmprof, FM3Str, "AutoviewHeight",
    1357                       &AutoviewHeight, &size);
     1361                      &AutoviewHeight, &size);
    13581362  size = sizeof(BOOL);
    13591363  PrfQueryProfileData(fmprof, FM3Str, "KeepCmdLine", &fKeepCmdLine, &size);
    … …  
    13751379  PrfQueryProfileData(fmprof, appname, "ShowEnv", &fShowEnv, &size);
    13761380  PrfQueryProfileString(fmprof, appname, "TreeEnvVarList", "PATH;DPATH;LIBPATH;HELP;BOOKSHELF;",
    1377                         pszTreeEnvVarList, MaxComLineStrg);
     1381                        pszTreeEnvVarList, MaxComLineStrg);
    13781382  size = sizeof(BOOL);
    13791383  PrfQueryProfileData(fmprof, appname, "LeaveTree", &fLeaveTree, &size);
    … …  
    14451449    size = sizeof(ULONG);
    14461450    if (PrfQueryProfileData(fmprof,
    1447                             FM3Str, szKey, (PVOID) &numsaves, &size)) {
     1451                            FM3Str, szKey, (PVOID) &numsaves, &size)) {
    14481452      for (x = numsaves - 1; x >= 0; x--) {
    1449         sprintf(szKey, "%s.DirCnrDir.%lu", GetPString(IDS_SHUTDOWNSTATE), x);
    1450         size = sizeof(szDir);
    1451         if (PrfQueryProfileData(fmprof, FM3Str, szKey, (PVOID) szDir, &size)) {
    1452           drvNum = toupper(*szDir) - 'A';
    1453           fDrivetoSkip[drvNum] = TRUE;
    1454         }
     1453        sprintf(szKey, "%s.DirCnrDir.%lu", GetPString(IDS_SHUTDOWNSTATE), x);
     1454        size = sizeof(szDir);
     1455        if (PrfQueryProfileData(fmprof, FM3Str, szKey, (PVOID) szDir, &size)) {
     1456          drvNum = toupper(*szDir) - 'A';
     1457          fDrivetoSkip[drvNum] = TRUE;
     1458        }
    14551459      }
    14561460    }
    … …  
    16461650    if (*argv[x] == '-') {
    16471651      if (!argv[x][1])
    1648         fNoSaveState = TRUE;
     1652        fNoSaveState = TRUE;
    16491653      else
    1650         strcpy(profile, &argv[x][1]);
     1654        strcpy(profile, &argv[x][1]);
    16511655    }
    16521656  }
    16531657
    16541658  hwndFrame = WinCreateStdWindow(HWND_DESKTOP,
    1655                                 WS_VISIBLE,
    1656                                 &FrameFlags,
    1657                                 WC_MAINWND,
    1658                                 NULL,
    1659                                 WS_VISIBLE | WS_ANIMATE,
    1660                                 FM3ModHandle, MAIN_FRAME, &hwndClient);
     1659                                WS_VISIBLE,
     1660                                &FrameFlags,
     1661                                WC_MAINWND,
     1662                                NULL,
     1663                                WS_VISIBLE | WS_ANIMATE,
     1664                                FM3ModHandle, MAIN_FRAME, &hwndClient);
    16611665  if (hwndFrame) {
    16621666    WinSetWindowUShort(hwndFrame, QWS_ID, MAIN_FRAME);
    … …  
    16751679      rcl.xRight -= bsz;
    16761680      WinSetWindowPos(hwndFrame,
    1677                       HWND_TOP,
    1678                       rcl.xLeft,
    1679                       rcl.yBottom,
    1680                       rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom, fl);
     1681                      HWND_TOP,
     1682                      rcl.xLeft,
     1683                      rcl.yBottom,
     1684                      rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom, fl);
    16811685    }
    16821686    if (fLogFile)
    … …  
    17011705  DosError(FERR_DISABLEHARDERR);
    17021706  if (DosOpen(filespec,
    1703               &handle,
    1704               &action,
    1705               0,
    1706               0,
    1707               OPEN_ACTION_FAIL_IF_NEW |
    1708               OPEN_ACTION_OPEN_IF_EXISTS,
    1709               OPEN_FLAGS_FAIL_ON_ERROR |
    1710               OPEN_FLAGS_NOINHERIT |
    1711               OPEN_FLAGS_RANDOMSEQUENTIAL |
    1712               OPEN_SHARE_DENYNONE | OPEN_ACCESS_READONLY, 0))
     1707              &handle,
     1708              &action,
     1709              0,
     1710              0,
     1711              OPEN_ACTION_FAIL_IF_NEW |
     1712              OPEN_ACTION_OPEN_IF_EXISTS,
     1713              OPEN_FLAGS_FAIL_ON_ERROR |
     1714              OPEN_FLAGS_NOINHERIT |
     1715              OPEN_FLAGS_RANDOMSEQUENTIAL |
     1716              OPEN_SHARE_DENYNONE | OPEN_ACCESS_READONLY, 0))
    17131717    ret = FALSE;
    17141718  else {
    … …  
    17171721    l = min(l, 79);
    17181722    if (!DosChgFilePtr(handle,
    1719                        abs(offset),
    1720                        (offset >= 0) ?
    1721                        FILE_BEGIN : FILE_END, &len)) {
     1723                       abs(offset),
     1724                       (offset >= 0) ?
     1725                       FILE_BEGIN : FILE_END, &len)) {
    17221726      if (!DosRead(handle, buffer, l, &len) && len == l) {
    1723         if (!memcmp(signature, buffer, l))
    1724           ret = TRUE;                   // Matched
     1727        if (!memcmp(signature, buffer, l))
     1728          ret = TRUE;                   // Matched
    17251729      }
    17261730    }
Note: See TracChangeset for help on using the changeset viewer.