Changeset 1544


Ignore:
Timestamp:
Sep 30, 2010, 3:00:59 PM (15 years ago)
Author:
Gregg Young
Message:

Changes to fopen and _fsopen to allow FM2 to be loaded in high memory

Location:
trunk/dll
Files:
47 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/arccnrs.c

    r1515 r1544  
    586586  ULONG apptype;
    587587  APIRET rc;
     588  CHAR *mode;
    588589
    589590  if (!arcname || !arcinfo)
    … …  
    653654    }
    654655    else {
    655       fp = xfopen(arctemp, "w", pszSrcFile, __LINE__);
     656      mode = "w";
     657      fp = xfopen(arctemp, mode, pszSrcFile, __LINE__, FALSE);
    656658      if (!fp) {
    657659        xfree(arctemp, pszSrcFile, __LINE__);
    … …  
    695697
    696698    DosError(FERR_DISABLEHARDERR);
    697     fp = _fsopen(arctemp, "r", SH_DENYWR);
     699    mode = "r";
     700    fp = xfsopen(arctemp, mode, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    698701
    699702    if (fp) {
    … …  
    20242027
    20252028                FILE *fp;
    2026                 CHAR szTempFile[CCHMAXPATH];
     2029                CHAR szTempFile[CCHMAXPATH];
     2030                CHAR *modew = "w";
    20272031
    20282032                BldFullPathName(szTempFile, pTmpDir, PCSZ_FM2PLAYTEMP);
    2029                 fp = xfopen(szTempFile, "w", pszSrcFile, __LINE__);
     2033                fp = xfopen(szTempFile, modew, pszSrcFile, __LINE__, FALSE);
    20302034                if (fp) {
    20312035                  fprintf(fp, "%s", ";AV/2-built FM2Play listfile\n");

  • trunk/dll/assoc.c

    r1521 r1544  
    170170  CHAR env[ENVIRONMENT_SIZE];
    171171  CHAR key[CCHMAXPATH];
     172  CHAR *moder = "r";
    172173
    173174  if (asshead)
    … …  
    175176  assloaded = TRUE;
    176177  BldFullPathName(mask, pFM2SaveDirectory, PCSZ_ASSOCDAT);
    177   fp = _fsopen(mask, "r", SH_DENYWR);
     178  fp = xfsopen(mask, moder, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    178179  pszCmdLine = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
    179180  if (!pszCmdLine) {
    … …  
    278279  FILE *fp;
    279280  CHAR s[CCHMAXPATH + 14];
     281  CHAR *modew = "w";
    280282
    281283  if (!assloaded || !asshead)
    … …  
    304306  if (CheckDriveSpaceAvail(s, ullDATFileSpaceNeeded, 1) == 2)
    305307    return; //already gave error msg
    306   fp = xfopen(s, "w", pszSrcFile, __LINE__);
     308  fp = xfopen(s, modew, pszSrcFile, __LINE__, FALSE);
    307309  if (fp) {
    308310    fputs(GetPString(IDS_ASSOCFILETEXT), fp);
    … …  
    433435  ULONG offset;
    434436  LINKASSOC *info;
     437  CHAR *moderb = "rb";
    435438
    436439  if (!assloaded)
    … …  
    462465      if (exclude && didmatch)
    463466        didmatch = FALSE;
    464       fp = _fsopen(datafile, "rb", SH_DENYNO);
     467      fp = xfsopen(datafile, moderb, SH_DENYNO, pszSrcFile, __LINE__, TRUE);
    465468      if (fp) {
    466469        if (!checked) {

  • trunk/dll/avl.c

    r1438 r1544  
    353353  UINT per_sig_comment_line_num = 0;
    354354  INT i;
     355  CHAR *moder = "r";
    355356
    356357  // Free current signatures
    … …  
    376377    return -1;
    377378  }
    378   fp = _fsopen(psz, "r", SH_DENYWR);
     379  fp = xfsopen(psz, moder, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    379380  DosReleaseMutexSem(hmtxFM2Globals);
    380381  //DosExitCritSec();

  • trunk/dll/avv.c

    r1498 r1544  
    230230  struct tm *tm;
    231231  CHAR ch;
     232  CHAR *mode;
    232233
    233234  arcsigsmodified = FALSE;
    … …  
    258259    strcpy(psz, PCSZ_DOTBB2);
    259260    DosMove(archiverbb2, sz);
    260     fpOld = fopen(sz, "r");             // OK for file not to exist
     261    mode = "r";
     262    fpOld = xfopen(sz, mode, pszSrcFile, __LINE__, TRUE);               // OK for file not to exist
    261263  }
    262 
    263   fpNew = fopen(archiverbb2, "w");
     264  mode = "w";
     265  fpNew = xfopen(archiverbb2, mode, pszSrcFile, __LINE__, TRUE);
    264266
    265267  if (fpNew) {
    … …  
    566568  case UM_SETUP:
    567569    if (admp->listname && *admp->listname) {
    568 
    569       FILE *fp = fopen(admp->listname, "r");
     570      FILE *fp;
     571      CHAR *moder = "r";
     572
     573      fp = xfopen(admp->listname, moder, pszSrcFile, __LINE__, TRUE);
    570574
    571575      if (!fp) {

  • trunk/dll/cmdline.c

    r1505 r1544  
    9797  //CHAR s[1024];
    9898  INT x = 0;
     99  CHAR *moder = "r";
    99100
    100101  pszCmdLine = xmalloc(MaxComLineStrg, pszSrcFile, __LINE__);
    … …  
    107108    BldFullPathName(pszCmdLine, pFM2SaveDirectory,
    108109                    (DoItYourself) ? PCSZ_CMDLINESDAT : PCSZ_CMDMINIDAT);
    109     fp = _fsopen(pszCmdLine, "r", SH_DENYWR);
     110    fp = xfsopen(pszCmdLine, moder, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    110111    if (fp) {
    111112      while (x < MAXNUMCMDLINES && !feof(fp)) {
    … …  
    152153  PSZ pszCmdLine;
    153154  //CHAR s[CCHMAXPATH + 14];
     155  CHAR *modew = "w";
    154156
    155157  CmdLineHead = (DoItYourself) ? DoItYourselfCmdLine : MiniCmdLine;
    … …  
    164166    return; //already gave error msg
    165167  if (CmdLineHead) {
    166     fp = xfopen(pszCmdLine, "w", pszSrcFile, __LINE__);
     168    fp = xfopen(pszCmdLine, modew, pszSrcFile, __LINE__, FALSE);
    167169    if (fp) {
    168170      fputs(GetPString(IDS_COMMANDFILE2TEXT), fp);

  • trunk/dll/collect.c

    r1513 r1544  
    771771      BOOL first = FALSE;
    772772      size_t c;
     773      CHAR *moder = "r";
    773774
    774775#     ifdef FORTIFY
    … …  
    776777#     endif
    777778
    778       fp = _fsopen((CHAR *)mp1, "r", SH_DENYNO);
     779      fp = xfsopen((CHAR *)mp1, moder, SH_DENYNO, pszSrcFile, __LINE__, TRUE);
    779780      if (fp) {
    780781        while (!feof(fp)) {

  • trunk/dll/command.c

    r1521 r1544  
    373373  CHAR title[100];
    374374  CHAR flags[34];
    375   //CHAR *p;
     375  CHAR *moder = "r";
    376376  ULONG size;
    377377
    … …  
    394394    if (pszCmdLine) {
    395395      BldFullPathName(pszCmdLine, pFM2SaveDirectory, PCSZ_COMMANDSDAT);
    396       fp = _fsopen(pszCmdLine, "r", SH_DENYWR);
     396      fp = xfsopen(pszCmdLine, moder, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    397397      if (fp) {
    398398        while (!feof(fp)) {

  • trunk/dll/comp.c

    r1505 r1544  
    221221  FILE *fp;
    222222  CHAR *p;
     223  CHAR *modew = "w";
    223224
    224225  if (sf) {
    … …  
    235236        p++;
    236237      }
    237       fp = xfopen(sf->filename, "w", pszSrcFile, __LINE__);
     238      fp = xfopen(sf->filename, modew, pszSrcFile, __LINE__, FALSE);
    238239      if (fp) {
    239240        fprintf(fp, "\"%s\"\n", sf->dirname);
    … …  
    261262  LONG numread1, numread2;
    262263  CHAR s[1024], ss[1024], *p1, *p2;
     264  CHAR *moderb = "rb";
    263265
    264266  if (args) {
    … …  
    293295        sprintf(s, GetPString(IDS_COMPTOTEXT), fc.file2);
    294296        AddToListboxBottom(fc.hwndList, s);
    295         fp1 = _fsopen(fc.file1, "rb", SH_DENYNO);
     297        fp1 = xfsopen(fc.file1, moderb, SH_DENYNO, pszSrcFile, __LINE__, TRUE);
    296298        if (!fp1) {
    297299          sprintf(s, GetPString(IDS_COMPCANTOPENTEXT), fc.file1);
    … …  
    300302        }
    301303        else {
    302           fp2 = _fsopen(fc.file2, "rb", SH_DENYNO);
     304          fp2 = xfsopen(fc.file2, moderb, SH_DENYNO, pszSrcFile, __LINE__, TRUE);
    303305          if (!fp2) {
    304306            sprintf(s, GetPString(IDS_COMPCANTOPENTEXT), fc.file2);
    … …  
    10731075          CHAR buf1[1024];
    10741076          CHAR buf2[1024];
    1075           HAB hab = WinQueryAnchorBlock(hwndCnrS);
     1077          HAB hab = WinQueryAnchorBlock(hwndCnrS);
     1078          CHAR *moderb = "rb";
    10761079
    10771080          if (!*pciS->pszFileName ||
    … …  
    10821085          }
    10831086
    1084           fp1 = _fsopen(pciS->pszFileName, "rb", SH_DENYNO);
     1087          fp1 = xfsopen(pciS->pszFileName, moderb, SH_DENYNO, pszSrcFile, __LINE__, TRUE);
    10851088          if (!fp1) {
    10861089            errLineNo = __LINE__;
    … …  
    10881091          }
    10891092          else {
    1090             fp2 = _fsopen(pciD->pszFileName, "rb", SH_DENYNO);
     1093            fp2 = xfsopen(pciD->pszFileName, moderb, SH_DENYNO, pszSrcFile, __LINE__, TRUE);
    10911094            if (!fp2) {
    10921095              errLineNo = __LINE__;
    … …  
    15661569        FILE *fp;
    15671570        FILEFINDBUF4L fb4;
    1568         CHAR str[CCHMAXPATH * 2], *p;
     1571        CHAR str[CCHMAXPATH * 2], *p;
     1572        CHAR *moder = "r";
    15691573
    15701574        memset(&fb4, 0, sizeof(fb4));
    1571         fp = fopen(cmp->rightlist, "r");
    1572         if (!fp)
     1575        fp = xfopen(cmp->rightlist, moder, pszSrcFile, __LINE__, FALSE);
     1576        /*if (!fp)
    15731577          Runtime_Error(pszSrcFile, __LINE__, "can not open %s (%d)",
    1574                         cmp->rightlist, errno);
    1575         else {
     1578                        cmp->rightlist, errno);*/
     1579        if (fp) {
    15761580          while (!feof(fp)) {
    15771581            // First get name of directory

  • trunk/dll/dircnrs.c

    r1526 r1544  
    18461846              strcat(newfile, sip.ret);
    18471847              test = IsFile(newfile);
    1848               if (test != 1)
    1849                 fp = fopen(newfile, "w");
     1848              if (test != 1) {
     1849                CHAR *modew = "w";
     1850
     1851                fp = xfopen(newfile, modew, pszSrcFile, __LINE__, TRUE);
     1852              }
    18501853              if (test != 1 && !fp) {
    18511854                saymsg(MB_ENTER,

  • trunk/dll/dirsize.c

    r1533 r1544  
    954954
    955955        CHAR szFileName[CCHMAXPATH];
    956         FILE *fp;
     956        FILE *fp;
     957        CHAR *modea = "a+";
    957958
    958959        if (pTmpDir)
    … …  
    967968              !strchr(szFileName, '.'))
    968969            strcat(szFileName, ".RPT");
    969           fp = fopen(szFileName, "a+");
     970          fp = xfopen(szFileName, modea, pszSrcFile, __LINE__, TRUE);
    970971          if (!fp) {
    971972            saymsg(MB_CANCEL,

  • trunk/dll/excputil.c

    r1533 r1544  
    223223    INT c;
    224224    FILE* fp;
     225    CHAR *modea = "a";
    225226
    226227    handled = TRUE;
    227228
    228229    // Write stack trace to log file - let kernel do popuplog.os2
    229     fp = fopen("fm2_trap.log", "a");
     230    fp = xfopen("fm2_trap.log", modea, pszSrcFile, __LINE__, TRUE);
    230231    if (!fp)
    231232      fp = stderr;                      // Oh well

  • trunk/dll/filldir.c

    r1543 r1544  
    392392    sprintf(psz, "%08x.%03x", rand() & 0xffffffff, rand() & 0xfff);
    393393    if (IsFile(szFileName) != 1) {
    394       FILE *fp = fopen(szFileName, "w");
     394      FILE *fp;
     395      CHAR *modew = "w";
     396
     397      fp = xfopen(szFileName, modew, pszSrcFile, __LINE__, TRUE);
    395398
    396399      if (fp) {

  • trunk/dll/filter.c

    r1498 r1544  
    154154  LINKMASKS *info, *last = NULL;
    155155  CHAR s[CCHMAXPATH + 24];
     156  CHAR *moder = "r";
    156157
    157158  loadedmasks = TRUE;
    158159  BldFullPathName(s, pFM2SaveDirectory, PCSZ_FILTERSDAT);
    159   fp = _fsopen(s, "r", SH_DENYWR);
     160  fp = xfsopen(s, moder, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    160161  if (fp) {
    161162    while (!feof(fp)) {
    … …  
    192193  FILE *fp;
    193194  CHAR s[CCHMAXPATH + 14];
     195  CHAR *modew = {"w"};
    194196
    195197  if (!loadedmasks)
    … …  
    199201    if (CheckDriveSpaceAvail(s, ullDATFileSpaceNeeded, 1) == 2)
    200202    return; //already gave error msg
    201     fp = xfopen(s, "w", pszSrcFile, __LINE__);
     203    fp = xfopen(s, modew, pszSrcFile, __LINE__, FALSE);
    202204    if (fp) {
    203205      fputs(GetPString(IDS_FILTERFILETEXT), fp);

  • trunk/dll/fortify.c

    r1442 r1544  
    24402440        {
    24412441        if(written_something == 0)
    2442         {
     2442        {
     2443                CHAR modew = "w";
    24432444                FORTIFY_FIRST_ERROR_FUNCTION;
    2444                 fp = fopen(FORTIFY_LOG_FILENAME, "w");
     2445                fp = xfopen(FORTIFY_LOG_FILENAME, modew, pszSrcFile, __LINE__, TRUE);
    24452446                if(fp)
    24462447                {

  • trunk/dll/grep.c

    r1524 r1544  
    10231023    if (input) {
    10241024      LONG len;
    1025 
    1026       inputFile = _fsopen(pszFileName, "rb", SH_DENYNO);
     1025      CHAR *moderb = "rb";
     1026
     1027      inputFile = xfsopen(pszFileName, moderb, SH_DENYNO, pszSrcFile, __LINE__, TRUE);
    10271028      if (inputFile) {
    10281029        pos = ftell(inputFile);
    … …  
    11441145  FILE *fp;
    11451146  CHAR *buffer;
     1147  CHAR *moderb = "rb";
    11461148
    11471149  *error = 0;
    … …  
    11501152    *error = -1;
    11511153  else {
    1152     fp = _fsopen(pszFileName, "rb", SH_DENYNO);
     1154    fp = xfsopen(pszFileName, moderb, SH_DENYNO, pszSrcFile, __LINE__, TRUE);
    11531155    if (!fp)
    11541156      *error = -2;

  • trunk/dll/grep2.c

    r1505 r1544  
    198198  CHAR path[CCHMAXPATH];
    199199  CHAR s[8192 + 14];
     200  CHAR *moder = "r";
    200201
    201202  // 07 Oct 09 SHL fixme to not be static and save to profile?
    … …  
    324325    // Fill mask listbox
    325326    BldFullPathName(s, pFM2SaveDirectory, PCSZ_GREPMASKDAT);
    326     fp = _fsopen(s, "r", SH_DENYWR);
     327    fp = xfsopen(s, moder, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    327328    if (fp) {
    328329      while (!feof(fp)) {
    … …  
    10141015                                            MPVOID, MPVOID);
    10151016        // 07 Oct 09 SHL Rewrite if list empty
    1016         if (sSelect >= 0) {
     1017        if (sSelect >= 0) {
     1018          CHAR *modew = "w";
     1019
    10171020          BldFullPathName(s, pFM2SaveDirectory, PCSZ_GREPMASKDAT);
    10181021          if (CheckDriveSpaceAvail(s, ullDATFileSpaceNeeded, 1) == 2)
    10191022            break; //already gave error msg
    1020           fp = xfopen(s, "w", pszSrcFile, __LINE__);
     1023          fp = xfopen(s, modew, pszSrcFile, __LINE__, FALSE);
    10211024          if (fp) {
    10221025            fputs(GetPString(IDS_GREPFILETEXT), fp);

  • trunk/dll/info.c

    r1543 r1544  
    670670      HPOINTER hptr;
    671671      ARC_TYPE *info;
     672      CHAR *mode;
    672673
    673674      DosError(FERR_DISABLEHARDERR);
    … …  
    827828          WinEnableWindow(WinWindowFromID(hwnd, FLE_OPEN), TRUE);
    828829          WinEnableWindow(WinWindowFromID(hwnd, FLE_ISARCHIVE), TRUE);
    829           WinEnableWindow(WinWindowFromID(hwnd, FLE_BINARY), TRUE);
    830           fp = _fsopen(pfs->szFileName, "rb", SH_DENYNO);
     830          WinEnableWindow(WinWindowFromID(hwnd, FLE_BINARY), TRUE);
     831          mode = "rb";
     832          fp = xfsopen(pfs->szFileName, mode, SH_DENYNO, pszSrcFile, __LINE__, TRUE);
    831833          if (fp) {
    832834            char buff[4096];            // 06 Oct 07 SHL protect against NTFS defect
    … …  
    851853            WinCheckButton(hwnd, FLE_ISARCHIVE, 2);
    852854            WinCheckButton(hwnd, FLE_BINARY, 2);
    853           }
    854           fp = _fsopen(pfs->szFileName, "ab", SH_DENYNO);
     855          }
     856          mode = "ab";
     857          fp = xfsopen(pfs->szFileName, mode, SH_DENYNO, pszSrcFile, __LINE__, TRUE);
    855858          if (fp) {
    856859            WinCheckButton(hwnd, FLE_WRITEABLE, TRUE);
    857860            fclose(fp);
    858           }
    859           fp = _fsopen(pfs->szFileName, "rb", SH_DENYRW);
     861          }
     862          mode = "rb";
     863          fp = xfsopen(pfs->szFileName, mode, SH_DENYRW, pszSrcFile, __LINE__, TRUE);
    860864          if (!fp)
    861865            WinCheckButton(hwnd, FLE_OPEN, TRUE);

  • trunk/dll/inis.c

    r1498 r1544  
    779779        FILE *fp;
    780780        INT len;
    781         SHORT sSelect;
     781        SHORT sSelect;
     782        CHAR *moder = "r";
    782783
    783784        sSelect = (SHORT) WinSendDlgItemMsg(hwnd, IAF_LISTBOX,
    … …  
    793794          bstrip(s);
    794795          if (*s) {
    795             fp = _fsopen(s, "r", SH_DENYWR);
     796            fp = xfsopen(s, moder, SH_DENYWR, pszSrcFile, __LINE__, FALSE);
    796797            if (fp) {
    797798              len = fread(s, 1, 8192, fp);
    … …  
    808809      {
    809810        CHAR s[8193], filename[CCHMAXPATH], *p;
    810         FILE *fp;
     811        FILE *fp;
     812        CHAR *modew = "w";
    811813
    812814        *filename = 0;
    … …  
    824826            Runtime_Error(pszSrcFile, __LINE__, NULL);
    825827          else {
    826             fp = xfopen(filename, "w", pszSrcFile, __LINE__);
     828            fp = xfopen(filename, modew, pszSrcFile, __LINE__, FALSE);
    827829            if (fp) {
    828830              fwrite(s, 1, strlen(s), fp);

  • trunk/dll/init.c

    r1522 r1544  
    385385  HDIR hdir = HDIR_CREATE;
    386386  APIRET rc = 1;
     387  CHAR *moder = "r";
    387388
    388389  *SwapperDat = 0;
    … …  
    407408    if (!rc) {
    408409      DosFindClose(hdir);
    409       fp = fopen(SwapperDat, "r");
     410      fp = xfopen(SwapperDat, moder, pszSrcFile, __LINE__, TRUE);
    410411      if (fp) {
    411412        fclose(fp);
    … …  
    426427    }
    427428    *filename = (CHAR) nm + '@';
    428     fp = xfsopen(filename, "r", SH_DENYNO, pszSrcFile, __LINE__);
     429    fp = xfsopen(filename, moder, SH_DENYNO, pszSrcFile, __LINE__, TRUE);
    429430    if (fp) {
    430431      while (!feof(fp)) {
    … …  
    16671668                      rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom, fl);
    16681669    }
    1669     if (fLogFile)
    1670       LogFileHandle = _fsopen("FM2.LOG", "a+", SH_DENYWR);
     1670    if (fLogFile) {
     1671      CHAR *modea = "a+";
     1672
     1673      LogFileHandle = xfsopen("FM2.LOG", modea, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
     1674    }
    16711675    if (hwndHelp)
    16721676      WinAssociateHelpInstance(hwndHelp, hwndFrame);

  • trunk/dll/instant.c

    r1480 r1544  
    100100        IPT iptOffset = 0L;
    101101        LONG len, tlen, mem;
    102         CHAR *rexx = "";
     102        CHAR *rexx = "";
     103        CHAR *modew = "w";
    103104
    104105        mem = MLEgetlen(hwndMLE);
    … …  
    137138                      (path[strlen(path) - 1] == '\\') ? NullStr : PCSZ_BACKSLASH,
    138139                      batches++);
    139               fp = fopen(s, "w");
    140               if (!fp)
    141                 Runtime_Error(pszSrcFile, __LINE__, "fopen");
    142               else {
     140              fp = xfopen(s, modew, pszSrcFile, __LINE__, FALSE);
     141              //if (!fp)
     142              //  Runtime_Error(pszSrcFile, __LINE__, "fopen");
     143              if (fp) {
    143144                if (!strncmp(bat, "/*", 2)) {
    144145                  rexx = "'";

  • trunk/dll/killproc.c

    r1505 r1544  
    254254  PID pid;
    255255  HFILE oldstdout, newstdout;
     256  CHAR *mode;
    256257
    257258  DosError(FERR_DISABLEHARDERR);
    … …  
    268269  BldFullPathName(s, pTmpDir, "$PSTAT#$.#$#");
    269270  unlinkf(s);
    270   fp = fopen(s, "w");
     271  mode = "w";
     272  fp = xfopen(s, mode, pszSrcFile, __LINE__, TRUE);
    271273  if (!fp) {
    272274    Win_Error(NULLHANDLE, HWND_DESKTOP, __FILE__, __LINE__,
    … …  
    296298    }
    297299  }
    298   fp = fopen(s, "r");
     300  mode = "r";
     301  fp = xfopen(s, mode, pszSrcFile, __LINE__, TRUE);
    299302  if (fp) {
    300303    while (!feof(fp)) {

  • trunk/dll/loadbmp.c

    r1486 r1544  
    7373  SIZEL sizel;
    7474  HPS hPS = WinGetPS(HWND_DESKTOP);
     75  CHAR *moderb = "rb";
    7576
    7677  if (!hPS) {
    … …  
    8081  }
    8182
    82   pf = _fsopen(pszFileName, "rb", SH_DENYWR);
     83  pf = xfsopen(pszFileName, moderb, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    8384  if (!pf) {
    8485    // OK for file to not exist - enable following for debug as needed

  • trunk/dll/mainwnd.c

    r1533 r1544  
    308308            CommaFmtULL(szQty, sizeof(szQty), ullFreeQty, ' ');
    309309            sprintf(s, "%s %s (%lu%%) %s", dv, szQty, ulPctFree, GetPString(IDS_FREETEXT));
    310           }
     310          }
     311          else
     312            sprintf(s, "%s ", dv);
    311313        }
    312314      }
    … …  
    19451947      }
    19461948      else
    1947         helpid = 0;
     1949        helpid = 0;
    19481950    }
    19491951    break;
    … …  
    20312033          (!hwndBubble ||
    20322034           WinQueryWindowULong(hwndBubble, QWL_USER) != hwnd) &&
    2033           !WinQueryCapture(HWND_DESKTOP)) {
    2034 
    2035         RECTL rcl;
     2035          !WinQueryCapture(HWND_DESKTOP)) {
     2036
     2037        RECTL rcl;
    20362038        POINTL ptl;
    20372039
    … …  
    20392041        WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl, 1);
    20402042        WinQueryWindowRect(hwnd, &rcl);
    2041         if (WinPtInRect(WinQueryAnchorBlock(hwnd), &rcl, &ptl))
    2042           BubbleHelp(hwnd, FALSE, TRUE, FALSE, (char *)mp1);
     2043        if (WinPtInRect(WinQueryAnchorBlock(hwnd), &rcl, &ptl)) {
     2044          BubbleHelp(hwnd, FALSE, TRUE, FALSE, (char *)mp1);
     2045        }
    20432046      }
    20442047    }

  • trunk/dll/mainwnd2.c

    r1506 r1544  
    14591459                      rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom, fl);
    14601460    }
    1461     if (fLogFile)
    1462       LogFileHandle = _fsopen("FM2.LOG", "a+", SH_DENYWR);
     1461    if (fLogFile) {
     1462      CHAR *modea = "a+";
     1463
     1464      LogFileHandle = xfsopen("FM2.LOG", modea, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
     1465    }
    14631466    if (hwndHelp)
    14641467      WinAssociateHelpInstance(hwndHelp, hwndFrame);

  • trunk/dll/menu.c

    r1402 r1544  
    8484  MENU *info, *last = NULL;
    8585  BOOL ret = FALSE;
     86  CHAR *moder = "r";
    8687
    8788  // fixme to complain?
    … …  
    9293  if (!filename)
    9394    filename = "FM3MENU.DAT";
    94   fp = _fsopen(filename, "r", SH_DENYWR);
     95  fp = xfsopen(filename, moder, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    9596  if (fp)  {
    9697    while (!feof(fp)) {

  • trunk/dll/misc.c

    r1533 r1544  
    10831083  FILE *fp;
    10841084  INT ret = -1;
    1085 
    1086   fp = _fsopen(filename, "rb", SH_DENYNO);
     1085  CHAR *moderb = "rb";
     1086
     1087  fp = xfsopen(filename, moderb, SH_DENYNO, pszSrcFile, __LINE__, FALSE);
    10871088  if (fp) {
    10881089    *s = 0;
    … …  
    21412142  PFN DQELIBPATH = NULL;
    21422143  HMODULE hmod;
     2144  CHAR *moder = "r";
    21432145
    21442146  if (str && len) {
    … …  
    21652167      *var = 0;
    21662168    }
    2167     fp = xfopen(configsys, "r", pszSrcFile, __LINE__);
     2169    fp = xfopen(configsys, moder, pszSrcFile, __LINE__, FALSE);
    21682170    if (fp) {
    21692171      while (!feof(fp)) {

  • trunk/dll/mle.c

    r1498 r1544  
    318318    {
    319319      FILE *fp;
    320 
    321       fp = fopen(filename, "a+");
    322       if (!fp)
    323         fp = xfopen(filename, "w", pszSrcFile, __LINE__);
     320      CHAR *mode = "a+";
     321
     322      fp = xfopen(filename, mode, pszSrcFile, __LINE__, TRUE);
     323      if (!fp) {
     324        mode = "w";
     325        fp = xfopen(filename, mode, pszSrcFile, __LINE__, FALSE);
     326      }
    324327      if (fp) {
    325328        fseek(fp, 0L, SEEK_END);
    … …  
    648651  XMLEWNDPTR *vw;
    649652  APIRET rc;
     653  CHAR *moder = "r";
    650654
    651655  *titletext = 0;
    … …  
    657661  *titletext = 0;
    658662  WinQueryWindowText(grandpa, 512, titletext);
    659   fp = _fsopen(filename, "r", SH_DENYNO);
     663  fp = xfsopen(filename, moder, SH_DENYNO, pszSrcFile, __LINE__, TRUE);
    660664  if (!fp)
    661665    ret = FALSE;
    … …  
    893897  BOOL fWrap = MLEgetwrap(h);
    894898  APIRET rc;
     899  CHAR *mode;
    895900
    896901  if (!MLEgetlen(h))                    /* nothing to save; forget it */
    … …  
    926931  }
    927932  else {
    928     fp = fopen(filename, "a+");
    929     if (!fp)
    930       fp = xfopen(filename, "w", pszSrcFile, __LINE__);
     933    mode = "a+";
     934    fp = xfopen(filename, mode, pszSrcFile, __LINE__, TRUE);
     935    if (!fp) {
     936      mode = "w";
     937      fp = xfopen(filename, mode, pszSrcFile, __LINE__, FALSE);
     938    }
    931939    if (!fp)
    932940      ok = FALSE;

  • trunk/dll/newview.c

    r1533 r1544  
    11871187
    11881188                  FILE *fp;
    1189                   CHAR filename[CCHMAXPATH];
     1189                  CHAR filename[CCHMAXPATH];
     1190                  CHAR *modea = "a+";
    11901191
    11911192                  *filename = 0;
    11921193                  if (export_filename(hwnd, filename, FALSE)) {
    1193                     fp = _fsopen(filename, "a+", SH_DENYWR);
     1194                    fp = xfsopen(filename, modea, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    11941195                    if (!fp) {
    11951196                      saymsg(MB_CANCEL,

  • trunk/dll/printer.c

    r1505 r1544  
    8181  CHAR param = 0, data = 0;
    8282  ULONG datalen = 1, parmlen = 1, htype, flagword;
     83  CHAR *modea = "a+";
    8384
    8485  if (!fWorkPlace)                      /* assume spooler is active */
    8586    return TRUE;
    8687  DosError(FERR_DISABLEHARDERR);
    87   printhandle = xfopen(printdevname, "a+", pszSrcFile, __LINE__);
     88  printhandle = xfopen(printdevname, modea, pszSrcFile, __LINE__, FALSE);
    8889  if (printhandle) {
    8990    if (!strnicmp(printdevname, "COM", 3) && isdigit(printdevname[3])) {
    … …  
    138139  int c;
    139140  APIRET rc = MBID_YES;
     141  CHAR *mode;
    140142
    141143  if (StopPrinting)
    … …  
    176178            Runtime_Error(pszSrcFile, __LINE__, "printer %s error",
    177179                          li->targetpath);
    178           else {
    179             fpi = _fsopen(li->list[x], "r", SH_DENYWR);
     180          else {
     181            mode = "r";
     182            fpi = xfsopen(li->list[x], mode, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    180183            if (!fpi)
    181184              Runtime_Error(pszSrcFile, __LINE__, "cannot open %s",
    182185                            li->list[x]);
    183             else {
    184               fpo = _fsopen(li->targetpath, "a+", SH_DENYRW);
     186            else {
     187              mode = "a+";
     188              fpo = xfsopen(li->targetpath, mode, SH_DENYRW, pszSrcFile, __LINE__, TRUE);
    185189              if (!fpo)
    186190                Runtime_Error(pszSrcFile, __LINE__, "cannot open %s",
    … …  
    310314                }
    311315                if (prnalt && prnformat && firstpass && pages > 1) {
    312                   fclose(fpo);
    313                   fpo = _fsopen(li->targetpath, "a+", SH_DENYRW);
     316                  fclose(fpo);
     317                  mode = "a+";
     318                  fpo = xfsopen(li->targetpath, mode, SH_DENYRW, pszSrcFile, __LINE__, TRUE);
    314319                  if (fpo) {
    315320                    rewind(fpi);

  • trunk/dll/remap.c

    r1498 r1544  
    8787  CHAR s[CCHMAXPATH + 14];
    8888  INT x = 0;
     89  CHAR *moder = "r";
    8990
    9091  loadedres = TRUE;
    9192  BldFullPathName(s, pFM2SaveDirectory, PCSZ_RESOURCEDAT);
    92   fp = _fsopen(s, "r", SH_DENYWR);
     93  fp = xfsopen(s, moder, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    9394  if (fp) {
    9495    while (x < MAXNUMRES && !feof(fp)) {
    … …  
    124125  FILE *fp;
    125126  CHAR s[CCHMAXPATH + 14];
     127  CHAR *modew = "w";
    126128
    127129  if (!loadedres)
    … …  
    131133    return; //already gave error msg
    132134  if (reshead) {
    133     fp = xfopen(s, "w", pszSrcFile, __LINE__);
     135    fp = xfopen(s, modew, pszSrcFile, __LINE__, FALSE);
    134136    if (fp) {
    135137      fputs(GetPString(IDS_REMOTEFILETEXT), fp);

  • trunk/dll/rename.c

    r1498 r1544  
    4444#include "strips.h"                     // bstrip
    4545#include "info.h"                       // driveflags
     46#include "wrappers.h"                   // xfopen
     47
     48static PSZ pszSrcFile = __FILE__;
    4649
    4750MRESULT EXPENTRY RenameProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
    … …  
    161164                                     GetPString(IDS_FILETEXT));
    162165        {
    163           FILE *fp = NULL;
     166          FILE *fp = NULL;
     167          CHAR *modeab = "ab";
    164168          if (~sourceexists & 2)
    165             fp = fopen(mv->source, "ab");
     169            fp = xfopen(mv->source, modeab, pszSrcFile, __LINE__, TRUE);
    166170          if ((!fp && ~sourceexists & 2) || !sourceexists)
    167171            strcpy(s, GetPString(IDS_CANTACCESSSOURCETEXT));

  • trunk/dll/saveclip.c

    r1525 r1544  
    284284      {
    285285        FILE *fp;
    286         CHAR s[CCHMAXPATH + 14];
     286        CHAR s[CCHMAXPATH + 14];
     287        CHAR *moder = "r";
    287288
    288289        BldFullPathName(s, pFM2SaveDirectory, PCSZ_PATTERNSDAT);
    289         fp = _fsopen(s, "r", SH_DENYWR);
     290        fp = xfsopen(s, moder, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    290291        if (fp) {
    291292          while (xfgets(s, 81, fp, pszSrcFile, __LINE__)) {
    … …  
    309310      CHAR szBuffer[CCHMAXPATH + 14];
    310311      FILE *fp;
     312      CHAR *modew = "w";
    311313
    312314      sMax = (SHORT) WinSendDlgItemMsg(hwnd, SAV_LISTBOX,
    … …  
    316318        if (CheckDriveSpaceAvail(szBuffer, ullDATFileSpaceNeeded, 1) == 2)
    317319          break; //already gave error msg
    318         fp = xfopen(szBuffer, "w", pszSrcFile, __LINE__);
     320        fp = xfopen(szBuffer, modew, pszSrcFile, __LINE__, FALSE);
    319321        if (fp) {
    320322          fputs(GetPString(IDS_LISTPATTERNTEXT), fp);
    … …  
    477479        if (!pci || (INT) pci == -1)
    478480          Runtime_Error(pszSrcFile, __LINE__, NULL);
    479         else {
    480           fp = _fsopen(savename, "r+", SH_DENYWR);
    481           if (!fp)
    482             Runtime_Error(pszSrcFile, __LINE__, "_fsopen");
    483           else {
     481        else {
     482          CHAR *moder = "r+";
     483
     484          fp = xfsopen(savename, moder, SH_DENYWR, pszSrcFile, __LINE__, FALSE);
     485          if (fp) {
    484486            fseek(fp, 0, SEEK_SET);
    485487            if (WinQueryButtonCheckstate(hwnd, SAV_APPEND) == 0)
    … …  
    645647      {
    646648        FILE *fp;
    647         CHAR s[CCHMAXPATH + 14];
     649        CHAR s[CCHMAXPATH + 14];
     650        CHAR *moder = "r";
    648651
    649652        BldFullPathName(s, pFM2SaveDirectory, PCSZ_PATTERNSDAT);
    650         fp = _fsopen(s, "r", SH_DENYWR);
     653        fp = xfsopen(s, moder, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    651654        if (fp) {
    652655          while (xfgets(s, 81, fp, pszSrcFile, __LINE__)) {
    … …  
    670673      CHAR szBuffer[CCHMAXPATH + 14];
    671674      FILE *fp;
     675      CHAR *modew = "w";
    672676
    673677      sMax = (SHORT) WinSendDlgItemMsg(hwnd,
    … …  
    678682        if (CheckDriveSpaceAvail(szBuffer, ullDATFileSpaceNeeded, 1) == 2)
    679683          break; //already gave error msg
    680         fp = xfopen(szBuffer, "w", pszSrcFile, __LINE__);
     684        fp = xfopen(szBuffer, modew, pszSrcFile, __LINE__, FALSE);
    681685        if (fp) {
    682686          fputs(GetPString(IDS_LISTPATTERNTEXT), fp);
    … …  
    830834        if (!list || !list[0])
    831835          Runtime_Error(pszSrcFile, __LINE__, NULL);
    832         else {
    833           fp = _fsopen(savename, "r+", SH_DENYWR);
    834           if (!fp)
    835             Runtime_Error(pszSrcFile, __LINE__, "_fsopen");
    836           else {
     836        else {
     837          CHAR *moder = "r+";
     838          fp = xfsopen(savename, moder, SH_DENYWR, pszSrcFile, __LINE__, FALSE);
     839          if (fp) {
    837840            fseek(fp, 0, SEEK_SET);
    838841            if (WinQueryButtonCheckstate(hwnd, SAV_APPEND) == 0)

  • trunk/dll/select.c

    r1413 r1544  
    131131    FILE *fp;
    132132    CHAR input[1024], *p;
    133 
    134     fp = _fsopen(filename, "r", SH_DENYNO);
     133    CHAR *moder = "r";
     134
     135    fp = xfsopen(filename, moder, SH_DENYNO, pszSrcFile, __LINE__, TRUE);
    135136    if (fp) {
    136137      while (!feof(fp)) {
    … …  
    252253          ULONG pos;
    253254          LONG len;
    254           FILE *inputFile;
    255 
    256           if ((inputFile = _fsopen(pci->pszFileName, "rb", SH_DENYNO)) != NULL) {
     255          FILE *inputFile;
     256          CHAR *moderb = "rb";
     257
     258          if ((inputFile = xfsopen(pci->pszFileName, moderb, SH_DENYNO,
     259                                   pszSrcFile, __LINE__, TRUE)) != NULL) {
    257260            pos = ftell(inputFile);
    258261            while (!feof(inputFile)) {
    … …  
    356359          LONG len;
    357360          FILE *inputFile;
    358 
    359           if ((inputFile = _fsopen(pci->pszFileName, "rb", SH_DENYNO)) != NULL) {
     361          CHAR *moderb = "rb";
     362
     363          if ((inputFile = xfsopen(pci->pszFileName, moderb, SH_DENYNO,
     364                                   pszSrcFile, __LINE__, TRUE)) != NULL) {
    360365            pos = ftell(inputFile);
    361366            while (!feof(inputFile)) {

  • trunk/dll/seticon.c

    r1348 r1544  
    5555        INT x;
    5656        HWND hwndDeskTop;
    57         FILE *fp;
     57        FILE *fp;
     58        CHAR *moderb = "rb";
    5859
    5960        hwndDeskTop = WinQueryDesktopWindow(WinQueryAnchorBlock(hwnd),
    … …  
    6364        icf.fFormat = ICON_DATA;
    6465        if (filename && *filename) {
    65           fp = xfsopen(filename, "rb", SH_DENYNO, pszSrcFile, __LINE__);
     66          fp = xfsopen(filename, moderb, SH_DENYNO, pszSrcFile, __LINE__, FALSE);
    6667          if (!fp)
    6768            break;

  • trunk/dll/sysinfo.c

    r1402 r1544  
    5252  FILE *fp;
    5353  HFILE oldstdout, newstdout;
     54  CHAR *mode = "w";
    5455
    5556  DosError(FERR_DISABLEHARDERR);
    … …  
    6364    BldFullPathName(szTempFile, pTmpDir, "$RMVIEW.#$#");
    6465    unlinkf(szTempFile);
    65     fp = xfopen(szTempFile, "w", pszSrcFile, __LINE__);
     66    fp = xfopen(szTempFile, mode, pszSrcFile, __LINE__, FALSE);
    6667    if (!fp)
    6768      goto Abort;
    … …  
    8485    if (!WinIsWindow(thab, hwnd))
    8586      goto Abort;
    86     fp = xfopen(szTempFile, "r", pszSrcFile, __LINE__);
     87    mode = "r";
     88    fp = xfopen(szTempFile, mode, pszSrcFile, __LINE__, FALSE);
    8789    if (fp) {
    8890      xfgets(s, sizeof(s), fp, pszSrcFile, __LINE__);

  • trunk/dll/systemf.c

    r1533 r1544  
    252252          if (!*listfile) {
    253253            FILE *fp;
    254 
     254            CHAR *modew = "w";
    255255
    256256            strcpy(listfile, pTmpDir ? pTmpDir : pFM2SaveDirectory);
    257257            MakeTempName(listfile, "$FM2LI$T", 2);
    258             fp = xfopen(listfile, "w",pszSrcFile,__LINE__);
     258            fp = xfopen(listfile, modew,pszSrcFile,__LINE__, FALSE);
    259259            if (fp) {
    260260              for (x = 0; list[x]; x++)

  • trunk/dll/tools.c

    r1505 r1544  
    8282  CHAR s[CCHMAXPATH + 14];
    8383  INT x;
     84  CHAR *moder = "r";
    8485
    8586  qtloaded = TRUE;
    … …  
    9394  }
    9495  BldFullPathName(s, pFM2SaveDirectory, PCSZ_QUICKTLSDAT);
    95   fp = _fsopen(s, "r", SH_DENYWR);
     96  fp = xfsopen(s, moder, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    9697  if (fp) {
    9798    x = 0;
    … …  
    119120  INT x = 0;
    120121  CHAR s[CCHMAXPATH + 14];
     122  CHAR *modew = "w";
    121123
    122124  if (!quicktool[0])
    … …  
    125127  if (CheckDriveSpaceAvail(s, ullDATFileSpaceNeeded, 1) == 2)
    126128    return; //already gave error msg
    127   fp = xfopen(s, "w", pszSrcFile, __LINE__);
     129  fp = xfopen(s, modew, pszSrcFile, __LINE__, FALSE);
    128130  if (fp) {
    129131    for (x = 0; quicktool[x] && x < 50; x++)
    … …  
    140142  CHAR help[80], text[80], flagstr[80], idstr[80], *fname;
    141143  TOOL *info;
     144  CHAR *moder = "r";
    142145
    143146  if (!fToolbar) {
    … …  
    154157    filename = fname;
    155158    strcpy(lasttoolbar, filename);
    156     fp = _fsopen(filename, "r", SH_DENYWR);
     159    fp = xfsopen(filename, moder, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    157160    if (fp) {
    158161      toolhead = free_tools();
    … …  
    213216  CHAR *fname;
    214217  TOOL *info;
     218  CHAR *modew = "w";
    215219
    216220  if (!filename)
    … …  
    242246  if (CheckDriveSpaceAvail(filename, ullDATFileSpaceNeeded, 1) == 2)
    243247    return; //already gave error msg
    244   fp = xfopen(filename, "w", pszSrcFile, __LINE__);
     248  fp = xfopen(filename, modew, pszSrcFile, __LINE__, FALSE);
    245249  if (fp) {
    246250    fprintf(fp, GetPString(IDS_TOOLFILETEXT), filename);

  • trunk/dll/undel.c

    r1438 r1544  
    7676  BOOL killme = FALSE;
    7777  FILESTATUS3 fsa;
     78  CHAR *mode = "w";
    7879
    7980  undelinfo = (struct tempstruct *)arg;
    … …  
    9394    BldFullPathName(szTempFile, pTmpDir, "$UDELETE.#$#");
    9495    unlinkf(szTempFile);
    95     fp = xfopen(szTempFile, "w", pszSrcFile, __LINE__);
     96    fp = xfopen(szTempFile, mode, pszSrcFile, __LINE__, FALSE);
    9697    if (!fp) {
    9798      Win_Error(NULLHANDLE, hwnd, pszSrcFile, __LINE__,
    … …  
    123124      fclose(fp);
    124125    }
    125     fp = xfopen(szTempFile, "r", pszSrcFile, __LINE__);
     126    mode = "r";
     127    fp = xfopen(szTempFile, mode, pszSrcFile, __LINE__, FALSE);
    126128    if (fp) {
    127129      xfgets(s, sizeof(s), fp, pszSrcFile, __LINE__);   // Skip 1st line
    … …  
    422424
    423425          FILE *fp;
    424           CHAR s[CCHMAXPATH + 1];
     426          CHAR s[CCHMAXPATH + 1];
     427          CHAR *modew = "w";
    425428
    426429          DosForceDelete("\\FMUNDEL.CMD");
    427           fp = xfopen("\\FMUNDEL.CMD", "w", pszSrcFile, __LINE__);
     430          fp = xfopen("\\FMUNDEL.CMD", modew, pszSrcFile, __LINE__, FALSE);
    428431          if (fp) {
    429432            while (sSelect >= 0) {

  • trunk/dll/uudecode.c

    r1438 r1544  
    6060  char buf[80];
    6161  char fakedest[CCHMAXPATH];
     62  CHAR *moder = "r";
    6263
    6364  if (!dest)
    6465    dest = fakedest;
    65   in = _fsopen(filename, "r", SH_DENYWR);
     66  in = xfsopen(filename, moder, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    6667  if (!in) {
    6768    saymsg(MB_CANCEL,
    … …  
    110111
    111112  /* create output file */
    112   out = _fsopen(dest, "ab+", SH_DENYWR);
     113  moder = "ab+";
     114  out = xfsopen(dest, moder, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    113115  if (!out) {
    114116    fclose(in);

  • trunk/dll/valid.c

    r1498 r1544  
    7979PCSZ ISOFS = "ISOFS";
    8080PCSZ FAT32 = "FAT32";
     81PCSZ FAT = "FAT";
    8182PCSZ HPFS386 = "HPFS386";
    8283PCSZ CBSIFS = "CBSIFS";
    … …  
    803804  }
    804805  if ((!strcmp(FileSystem, HPFS) ||
     806       !strcmp(FileSystem, FAT) ||
    805807       !strcmp(FileSystem, JFS) ||
    806808       !strcmp(FileSystem, FAT32) ||

  • trunk/dll/valid.h

    r1444 r1544  
    4747extern PCSZ CDFS;
    4848extern PCSZ FAT32;
     49extern PCSZ FAT;
    4950extern PCSZ HPFS;
    5051extern PCSZ HPFS386;

  • trunk/dll/viewer.c

    r1505 r1544  
    910910        {
    911911          /* zero file length instead of unlink (protects EAs from loss) */
    912           FILE *fp;
    913 
    914           fp = fopen(vw->exportfilename, "r+"); //, pszSrcFile, __LINE__);
     912          FILE *fp;
     913          CHAR *moder = "r+";
     914
     915          fp = xfopen(vw->exportfilename, moder, pszSrcFile, __LINE__, TRUE);
    915916          if (fp) {
    916917            oldsize = filelength(fileno(fp));
    … …  
    923924                           vw->ExpandTabs,
    924925                           vw->fStripTrailLines, vw->fStripTrail)) {
    925           FILE *fp;
     926          FILE *fp;
     927          CHAR *moder = "r+";
    926928
    927929          Runtime_Error(pszSrcFile, __LINE__, "MLEexportfile");
    928           fp = xfopen(vw->exportfilename, "r+", pszSrcFile, __LINE__);
     930          fp = xfopen(vw->exportfilename, moder, pszSrcFile, __LINE__, FALSE);
    929931          if (fp) {
    930932            DosSetFileSize(fileno(fp), oldsize);

  • trunk/dll/viewinf.c

    r1505 r1544  
    142142                    FILE *fp;
    143143                    CHAR title[CCHMAXPATH];
     144                    CHAR *moderb = "rb";
    144145
    145146                    *title = 0;
    146                     fp = _fsopen(mask, "rb", SH_DENYNO);
     147                    fp = xfsopen(mask, moderb, SH_DENYNO, pszSrcFile, __LINE__, TRUE);
    147148                    if (fp) {
    148149                      fread(title, 1, 3, fp);
    … …  
    539540        FILE *fp;
    540541        BOOL notfirst = FALSE;
     542        CHAR *modew = "w";
    541543
    542544        sSelect = (SHORT) WinSendDlgItemMsg(hwnd,
    … …  
    573575          }
    574576          BldFullPathName(filename, pFM2SaveDirectory, "FM2VINF.CMD");
    575           fp = xfopen(filename, "w", pszSrcFile, __LINE__);
     577          fp = xfopen(filename, modew, pszSrcFile, __LINE__, FALSE);
    576578          if (fp) {
    577579            fprintf(fp, "@ECHO OFF\nSET FM2REF=");

  • trunk/dll/walkem.c

    r1505 r1544  
    377377  LINKDIRS *last = NULL;
    378378  CHAR s[CCHMAXPATH + 24];
     379  CHAR *moder = "r";
    379380
    380381  if (udirhead)
    … …  
    383384  fUdirsChanged = FALSE;
    384385  BldFullPathName(s, pFM2SaveDirectory, PCSZ_USERDIRSDAT);
    385   fp = _fsopen(s, "r", SH_DENYWR);
     386  fp = xfsopen(s, moder, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    386387  if (fp) {
    387388    while (!feof(fp)) {
    … …  
    424425  LINKDIRS *info;
    425426  CHAR s[CCHMAXPATH + 14];
     427  CHAR *modew = "w";
    426428
    427429  if (loadedudirs) {
    … …  
    431433      if (CheckDriveSpaceAvail(s, ullDATFileSpaceNeeded, 1) == 2)
    432434        return; //already gave error msg
    433       fp = xfopen(s, "w", pszSrcFile, __LINE__);
     435      fp = xfopen(s, modew, pszSrcFile, __LINE__, FALSE);
    434436      if (fp) {
    435437        fputs(GetPString(IDS_USERDEFDIRSTEXT), fp);

  • trunk/dll/worker.c

    r1498 r1544  
    378378                    break;
    379379                  }
    380                   in = _fsopen(wk->li->list[x], moder, SH_DENYWR);
     380                  in = xfsopen(wk->li->list[x], moder, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
    381381                  if (!in) {
    382382                    if (saymsg(MB_ENTERCANCEL,
    … …  
    388388                  }
    389389                  else {
    390                     out = _fsopen(wk->li->targetpath, modew, SH_DENYWR);
     390                    out = xfsopen(wk->li->targetpath, modew, SH_DENYWR,
     391                                  pszSrcFile, __LINE__, TRUE);
    391392                    if (out) {
    392393                      fseek(out, 0L, SEEK_END);
    … …  
    11671168
    11681169                FILE *fp;
    1169                 CHAR szTempFile[CCHMAXPATH];
     1170                CHAR szTempFile[CCHMAXPATH];
     1171                CHAR *modew = "w";
    11701172
    11711173                BldFullPathName(szTempFile, pTmpDir, PCSZ_FM2PLAYTEMP);
    1172                 fp = xfopen(szTempFile, "w", pszSrcFile, __LINE__);
     1174                fp = xfopen(szTempFile, modew, pszSrcFile, __LINE__, FALSE);
    11731175                if (fp) {
    11741176                  fprintf(fp, "%s", ";AV/2-built FM2Play listfile\n");

  • trunk/dll/wrappers.c

    r1476 r1544  
    370370}
    371371
     372/**
     373 * Wrapper for fopen it works around DosOpenL's failure to
     374 * thunk properly so that fm2 can be loaded in high memory
     375 * It also gives the option of reporting file open errors
     376 * If fSilent is TRUE it fails silently; if FALSE it produces a
     377 * runtime error dialog. Note pszMode must be passed on the stack
     378 * to xfopen to avoid the thunking problem.
     379 */
     380
    372381FILE *xfopen(PCSZ pszFileName, PCSZ pszMode, PCSZ pszSrcFile,
    373              UINT uiLineNumber)
    374 {
    375   FILE *fp = fopen(pszFileName, pszMode);
    376 
    377   if (!fp)
     382             UINT uiLineNumber, BOOL fSilent)
     383{
     384  CHAR FileName[CCHMAXPATH];
     385  FILE *fp;
     386
     387  strcpy(FileName, pszFileName);
     388  fp = fopen(FileName, pszMode);
     389
     390  if (!fp && !fSilent)
    378391    Runtime_Error(pszSrcFile, uiLineNumber, "fopen");
    379392  return fp;
    380393}
    381394
     395/**
     396 * Wrapper for _fsopen it works around DosOpenL's failure to
     397 * thunk properly so that fm2 can be loaded in high memory
     398 * It also gives the option of reporting file open errors
     399 * If fSilent is TRUE it fails silently; if FALSE it produces a
     400 * runtime error dialog. Note pszMode must be passed on the stack
     401 * to xfopen to avoid the thunking problem
     402 */
     403
    382404FILE *xfsopen(PCSZ pszFileName, PCSZ pszMode, INT fSharemode, PCSZ pszSrcFile,
    383               UINT uiLineNumber)
    384 {
    385   FILE *fp = _fsopen(pszFileName, pszMode, fSharemode);
    386 
    387   if (!fp)
     405              UINT uiLineNumber, BOOL fSilent)
     406{
     407  CHAR FileName[CCHMAXPATH];
     408  FILE *fp;
     409
     410  strcpy(FileName, pszFileName);
     411  fp = _fsopen(FileName, pszMode, fSharemode);
     412
     413  if (!fp && !fSilent)
    388414    Runtime_Error(pszSrcFile, uiLineNumber, "_fsopen");
    389415  return fp;

  • trunk/dll/wrappers.h

    r1439 r1544  
    5656                    UINT uiLineNumber);
    5757FILE *xfopen(PCSZ pszFileName, PCSZ pszMode, PCSZ pszSrcFile,
    58              UINT uiLineNumber);
     58             UINT uiLineNumber, BOOL fSilent);
    5959VOID xfree(PVOID pv, PCSZ pszSrcFile, UINT uiLineNumber);
    6060FILE *xfsopen(PCSZ pszFileName, PCSZ pszMode, INT fSharemode, PCSZ pszSrcFile,
    61               UINT uiLineNumber);
     61              UINT uiLineNumber, BOOL fSilent);
    6262PVOID xmalloc(size_t cBytes, PCSZ pszSrcFile, UINT uiLineNumber);
    6363PVOID xmallocz(size_t cBytes, PCSZ pszSrcFile, UINT uiLineNumber);
Note: See TracChangeset for help on using the changeset viewer.