Changeset 730


Ignore:
Timestamp:
Jul 22, 2007, 5:57:09 PM (13 years ago)
Author:
Gregg Young
Message:

Preliminary work on variable sized container buffers. Removes szFileName etc. Builds fine but traps.

Location:
trunk/dll
Files:
25 edited

Legend:

Unmodified
Added
Removed
  • trunk/dll/arccnrs.c

    r705 r730  
    189189    switch (sortFlags & (~SORT_REVERSE)) {
    190190    case SORT_FIRSTEXTENSION:
    191       pext = strchr(pai1->szFileName, '.');
    192       ppext = strchr(pai2->szFileName, '.');
     191      pext = strchr(pai1->pszFileName, '.');
     192      ppext = strchr(pai2->pszFileName, '.');
    193193      if (!pext)
    194194        pext = NullStr;
     
    199199
    200200    case SORT_LASTEXTENSION:
    201       pext = strrchr(pai1->szFileName, '.');
    202       ppext = strrchr(pai2->szFileName, '.');
     201      pext = strrchr(pai1->pszFileName, '.');
     202      ppext = strrchr(pai2->pszFileName, '.');
    203203      if (!pext)
    204204        pext = NullStr;
     
    244244    }
    245245    if (!ret)
    246       ret = (SHORT) stricmp(pai1->szFileName, pai2->szFileName);
     246      ret = (SHORT) stricmp(pai1->pszFileName, pai2->pszFileName);
    247247    if (ret && (sortFlags & SORT_REVERSE))
    248248      ret = ret > 0 ? -1 : 1;
    249249    return ret;
    250250  }
    251   return (SHORT) stricmp(pai1->szFileName, pai2->szFileName);
     251  return (SHORT) stricmp(pai1->pszFileName, pai2->pszFileName);
    252252}
    253253
     
    265265        if (*dcd->mask.pszMasks[x]) {
    266266          if (*dcd->mask.pszMasks[x] != '/') {
    267             if (wildcard(r->szFileName, dcd->mask.pszMasks[x], FALSE))
     267            if (wildcard(r->pszFileName, dcd->mask.pszMasks[x], FALSE))
    268268              ret = TRUE;
    269269          }
    270270          else {
    271             if (wildcard(r->szFileName, dcd->mask.pszMasks[x] + 1, FALSE)) {
     271            if (wildcard(r->pszFileName, dcd->mask.pszMasks[x] + 1, FALSE)) {
    272272              ret = FALSE;
    273273              break;
     
    278278    }
    279279    else {
    280       if (wildcard(r->szFileName, dcd->mask.szMask, FALSE))
     280      if (wildcard(r->pszFileName, dcd->mask.szMask, FALSE))
    281281        ret = TRUE;
    282282    }
     
    585585                  fname[strlen(fname) - 1] == '/')
    586586                pai->flags = ARCFLAGS_REALDIR;
    587               strcpy(pai->szFileName, fname);
     587              pai->pszFileName = xstrdup(fname,pszSrcFile, __LINE__);
    588588              if (fdate)
    589589                strcpy(pai->szDate, fdate);
    590               pai->pszFileName = pai->szFileName;
     590              // pai->pszFileName = pai->pszFileName;
    591591              pai->rc.pszIcon = pai->pszFileName;
    592592              pai->rc.hptrIcon = (pai->flags & ARCFLAGS_REALDIR) != 0 ?
     
    13181318                            IDS_SELECTFILTERTEXT : IDS_DESELECTFILTERTEXT));
    13191319          if (pci && (INT) pci != -1)
    1320             strcpy(mask.szMask, pci->szFileName);
     1320            strcpy(mask.szMask, pci->pszFileName);
    13211321          if (WinDlgBox(HWND_DESKTOP, dcd->hwndCnr, PickMaskDlgProc,
    13221322                        FM3ModHandle, MSK_FRAME, MPFROMP(&mask))) {
     
    21522152              sprintf(s, "%s%s%s%s",
    21532153                      *tb ? " " : NullStr,
    2154                       tb, *tb ? "  " : NullStr, pci->szFileName);
     2154                      tb, *tb ? "  " : NullStr, pci->pszFileName);
    21552155              WinSetWindowText(hwndStatus2, s);
    21562156            }
    21572157            if (fMoreButtons)
    2158               WinSetWindowText(hwndName, pci->szFileName);
     2158              WinSetWindowText(hwndName, pci->pszFileName);
    21592159          }
    21602160          else {
     
    27482748            empty = TRUE;
    27492749            pci = (PARCITEM) CurrentRecord(hwnd);
    2750             if (pci && strchr(pci->szFileName, '.'))
    2751               strcpy(dcd->mask.szMask, pci->szFileName);
     2750            if (pci && strchr(pci->pszFileName, '.'))
     2751              strcpy(dcd->mask.szMask, pci->pszFileName);
    27522752          }
    27532753
     
    28682868                                            MPFROMSHORT(CRA_CURSORED));
    28692869              if (pai && (INT) pai != -1)
    2870                 strcpy(li->runfile, pai->szFileName);
     2870                strcpy(li->runfile, pai->pszFileName);
    28712871              else
    28722872                strcpy(li->runfile, li->list[0]);
     
    31323132                  sprintf(s, "%s%s%s%s",
    31333133                          *tb ? " " : NullStr,
    3134                           tb, *tb ? "  " : NullStr, pci->szFileName);
     3134                          tb, *tb ? "  " : NullStr, pci->pszFileName);
    31353135                  WinSetWindowText(hwndStatus2, s);
    31363136                }
    31373137                if (fMoreButtons)
    3138                   WinSetWindowText(hwndName, pci->szFileName);
     3138                  WinSetWindowText(hwndName, pci->pszFileName);
    31393139              }
    31403140            }
     
    31553155                (pci->flags & (ARCFLAGS_REALDIR | ARCFLAGS_PSEUDODIR)))
    31563156              break;
    3157             s = xstrdup(pci->szFileName, pszSrcFile, __LINE__);
     3157            s = xstrdup(pci->pszFileName, pszSrcFile, __LINE__);
    31583158            if (s) {
    31593159              if (!PostMsg(dcd->hwndObject, UM_ENTER, MPFROMP(s), MPVOID)) {
  • trunk/dll/collect.c

    r724 r730  
    794794                            IDS_SELECTFILTERTEXT : IDS_DESELECTFILTERTEXT));
    795795          if (pci && (INT) pci != -1)
    796             strcpy(mask.szMask, pci->szFileName);
     796            strcpy(mask.szMask, pci->pszFileName);
    797797          if (WinDlgBox(HWND_DESKTOP, dcd->hwndCnr, PickMaskDlgProc,
    798798                        FM3ModHandle, MSK_FRAME, MPFROMP(&mask))) {
     
    10841084                         MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
    10851085        if (pci && (INT) pci != -1 &&
    1086             (!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_SLOW)))
    1087           WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->szFileName), MPVOID);
     1086            (!(driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_SLOW)))
     1087          WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->pszFileName), MPVOID);
    10881088        else
    10891089          WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
     
    11221122                           MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
    11231123          if (pci && (INT) pci != -1)
    1124             PostMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->szFileName), MPVOID);
     1124            PostMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->pszFileName), MPVOID);
    11251125          else
    11261126            PostMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
     
    11491149              p = pci->pszFileName;
    11501150            else {
    1151               p = strrchr(pci->szFileName, '\\');
     1151              p = strrchr(pci->pszFileName, '\\');
    11521152              if (p) {
    11531153                if (*(p + 1))
     
    14441444            static CHAR dirname[CCHMAXPATH];
    14451445
    1446             strcpy(dirname, pci->szFileName);
     1446            strcpy(dirname, pci->pszFileName);
    14471447            MakeValidDir(dirname);
    14481448            StartSeeAll(HWND_DESKTOP, FALSE, dirname);
     
    14821482            WinQueryWindowPos(dcd->hwndFrame, &swp);
    14831483            DefaultViewKeys(hwnd, dcd->hwndFrame, dcd->hwndParent, &swp,
    1484                             pci->szFileName);
     1484                            pci->pszFileName);
    14851485          }
    14861486        }
     
    17001700          pci = (PCNRITEM) CurrentRecord(hwnd);
    17011701          if (pci) {
    1702             strcpy(path, pci->szFileName);
     1702            strcpy(path, pci->pszFileName);
    17031703            MakeValidDir(path);
    17041704            WinDlgBox(HWND_DESKTOP, hwnd, UndeleteDlgProc, FM3ModHandle,
     
    17411741            pci = (PCNRITEM) CurrentRecord(hwnd);
    17421742            if (pci && !(pci->attrFile & FILE_DIRECTORY)) {
    1743               p = strrchr(pci->szFileName, '\\');
     1743              p = strrchr(pci->pszFileName, '\\');
    17441744              if (p) {
    17451745                p++;
     
    17631763                               MPFROMSHORT(CRA_CURSORED));
    17641764              if (pci && (INT) pci != -1 &&
    1765                   (!(driveflags[toupper(*pci->szFileName) - 'A'] &
     1765                  (!(driveflags[toupper(*pci->pszFileName) - 'A'] &
    17661766                     DRIVE_SLOW)))
    1767                 WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->szFileName),
     1767                WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->pszFileName),
    17681768                           MPVOID);
    17691769              else
     
    19131913          if (pci && (INT) pci != -1)
    19141914            WinDlgBox(HWND_DESKTOP, HWND_DESKTOP, DirSizeProc, FM3ModHandle,
    1915                       DSZ_FRAME, pci->szFileName);
     1915                      DSZ_FRAME, pci->pszFileName);
    19161916        }
    19171917        break;
     
    19231923          pci = (PCNRITEM) CurrentRecord(hwnd);
    19241924          PMMkDir(dcd->hwndParent, (pci && (INT) pci != -1) ?
    1925                   pci->szFileName : NULL, FALSE);
     1925                  pci->pszFileName : NULL, FALSE);
    19261926        }
    19271927        break;
     
    21372137                 (pci) ? NullStr : GetPString(IDS_NOTEXT),
    21382138                 (pci) ? NullStr : " ",
    2139                  (pci) ? pci->szFileName : NullStr,
     2139                 (pci) ? pci->pszFileName : NullStr,
    21402140                 (pci) ? " " : NullStr,
    21412141                 GetPString((usOperation == DO_COPY) ?
     
    21882188              }
    21892189              if (uso != DO_LINK &&
    2190                   !(driveflags[toupper(*pci->szFileName) - 'A'] &
     2190                  !(driveflags[toupper(*pci->pszFileName) - 'A'] &
    21912191                    DRIVE_NOTWRITEABLE)) {
    21922192                ARC_TYPE *info = NULL;
    21932193
    21942194                if (!fQuickArcFind &&
    2195                     !(driveflags[toupper(*pci->szFileName) - 'A'] &
     2195                    !(driveflags[toupper(*pci->pszFileName) - 'A'] &
    21962196                      DRIVE_SLOW))
    2197                   info = find_type(pci->szFileName, NULL);
     2197                  info = find_type(pci->pszFileName, NULL);
    21982198                else
    2199                   info = quick_find_type(pci->szFileName, NULL);
     2199                  info = quick_find_type(pci->pszFileName, NULL);
    22002200                if (!info || ((uso == DO_MOVE && !info->move) ||
    22012201                              (uso == DO_COPY && !info->create))) {
     
    22132213            DrgFreeDraginfo(pDInfo);    /* Free DRAGINFO */
    22142214            if (pci) {
    2215               if (driveflags[toupper(*pci->szFileName) - 'A'] &
     2215              if (driveflags[toupper(*pci->pszFileName) - 'A'] &
    22162216                  DRIVE_NOTWRITEABLE)
    22172217                return MRFROM2SHORT(DOR_DROP, DO_LINK);
    2218               if (toupper(*pci->szFileName) < 'C')
     2218              if (toupper(*pci->pszFileName) < 'C')
    22192219                return MRFROM2SHORT(DOR_DROP, DO_COPY);
    22202220              return MRFROM2SHORT(DOR_DROP,     /* Return okay to drop */
     
    22402240              if (pci->rc.flRecordAttr & CRA_SELECTED)
    22412241                wasemphasized = TRUE;
    2242               if (IsRoot(pci->szFileName))
     2242              if (IsRoot(pci->pszFileName))
    22432243                break;
    22442244              if (hwndStatus2)
     
    24562456                    p = pci->pszFileName;
    24572457                  else {
    2458                     p = strrchr(pci->szFileName, '\\');
     2458                    p = strrchr(pci->pszFileName, '\\');
    24592459                    if (p) {
    24602460                      if (*(p + 1))
     
    25042504                       MPFROMP(((fComments
    25052505                                 || (pci->attrFile & FILE_DIRECTORY) ==
    2506                                  0) ? pci->szFileName : NULL)), MPVOID);
     2506                                 0) ? pci->pszFileName : NULL)), MPVOID);
    25072507        }
    25082508        break;
     
    25212521              break;
    25222522            DosError(FERR_DISABLEHARDERR);
    2523             status = DosFindFirst(pci->szFileName, &hDir,
     2523            status = DosFindFirst(pci->pszFileName, &hDir,
    25242524                                  FILE_NORMAL | FILE_DIRECTORY |
    25252525                                  FILE_ARCHIVED | FILE_READONLY |
     
    25352535                else if ((shiftstate & (KC_CTRL | KC_SHIFT)) ==
    25362536                         (KC_CTRL | KC_SHIFT))
    2537                   OpenObject(pci->szFileName, Settings, dcd->hwndFrame);
     2537                  OpenObject(pci->pszFileName, Settings, dcd->hwndFrame);
    25382538                else if (shiftstate & KC_CTRL)
    2539                   OpenObject(pci->szFileName, Default, dcd->hwndFrame);
     2539                  OpenObject(pci->pszFileName, Default, dcd->hwndFrame);
    25402540                else
    25412541                  OpenDirCnr(HWND_DESKTOP,
    25422542                             hwndMain,
    2543                              dcd->hwndFrame, FALSE, pci->szFileName);
     2543                             dcd->hwndFrame, FALSE, pci->pszFileName);
    25442544              }
    25452545              else {
     
    25522552                DefaultViewKeys(hwnd,
    25532553                                dcd->hwndFrame,
    2554                                 dcd->hwndParent, &swp, pci->szFileName);
     2554                                dcd->hwndParent, &swp, pci->pszFileName);
    25552555                WinSendMsg(hwnd,
    25562556                           CM_SETRECORDEMPHASIS,
  • trunk/dll/comp.c

    r689 r730  
    355355  CHAR newname[CCHMAXPATH], dirname[CCHMAXPATH], *p;
    356356  APIRET rc;
     357  CHAR *f = 0;
    357358
    358359  if (!cmp)
     
    414415        pciOn = WinSendMsg(hwndCnrD, CM_QUERYRECORD, MPFROMP(pciO),
    415416                           MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
    416         if (*pci->szFileName && (pci->rc.flRecordAttr & CRA_SELECTED)) {
     417        if (*pci->pszFileName && (pci->rc.flRecordAttr & CRA_SELECTED)) {
    417418          switch (cmp->action) {
    418419          case IDM_DELETE:
    419             if (!unlinkf("%s", pci->szFileName)) {
     420            if (!unlinkf("%s", pci->pszFileName)) {
    420421              WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pci),
    421422                         MPFROM2SHORT(FALSE, CRA_SELECTED));
    422               if (!*pciO->szFileName) {
     423              if (!*pciO->pszFileName) {
    423424                WinSendMsg(hwndCnrS, CM_REMOVERECORD, MPFROMP(&pci),
    424425                           MPFROM2SHORT(1, CMA_FREE | CMA_INVALIDATE));
     
    429430                           MPFROM2SHORT(1, CMA_FREE | CMA_INVALIDATE));
    430431              }
    431               else {
    432                 *pci->szFileName = 0;
    433                 pci->pszFileName = pci->szFileName;
     432              else {
     433                pci->pszFileName = xstrdup(f, pszSrcFile, __LINE__);
     434                //pci->pszFileName = pci->szFileName;
    434435                pci->flags = 0;
    435436                WinSendMsg(hwndCnrS, CM_INVALIDATERECORD, MPFROMP(&pci),
     
    463464                MassMkdir(hwndMain, dirname);
    464465            }
    465             rc = docopyf(MOVE, pci->szFileName, "%s", newname);
    466             if (!rc && stricmp(pci->szFileName, newname)) {
     466            rc = docopyf(MOVE, pci->pszFileName, "%s", newname);
     467            if (!rc && stricmp(pci->pszFileName, newname)) {
    467468              WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pci),
    468469                         MPFROM2SHORT(FALSE, CRA_SELECTED));
     
    470471                WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciO),
    471472                           MPFROM2SHORT(FALSE, CRA_SELECTED));
    472               strcpy(pciO->szFileName, newname);
     473              pciO->pszFileName = xstrdup(newname, pszSrcFile, __LINE__);
    473474              if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR)) {
    474                 pciO->pszFileName = pciO->szFileName + strlen(cmp->leftdir);
     475                pciO->pszFileName = pciO->pszFileName + strlen(cmp->leftdir);
    475476                if (cmp->leftdir[strlen(cmp->leftdir) - 1] != '\\')
    476477                  pciO->pszFileName++;
    477478              }
    478479              else {
    479                 pciO->pszFileName = pciO->szFileName + strlen(cmp->rightdir);
     480                pciO->pszFileName = pciO->pszFileName + strlen(cmp->rightdir);
    480481                if (cmp->rightdir[strlen(cmp->rightdir) - 1] != '\\')
    481482                  pciO->pszFileName++;
    482               }
     483              }
    483484              strcpy(pciO->szDispAttr, pci->szDispAttr);
    484485              pciO->attrFile = pci->attrFile;
     
    492493              pciO->cbFile = pci->cbFile;
    493494              pciO->easize = pci->easize;
    494               *pciO->szSubject = 0;
    495               *pci->szFileName = 0;
    496               pci->pszFileName = pci->szFileName;
     495              pciO->pszSubject = xstrdup(f, pszSrcFile, __LINE__);
     496              pci->pszFileName = xstrdup(f, pszSrcFile, __LINE__);
     497              //pci->pszFileName = pci->szFileName;
    497498              pci->flags = 0;
    498499              WinSendMsg(hwndCnrS, CM_INVALIDATERECORD, MPFROMP(&pci),
     
    508509                             __LINE__,
    509510                             GetPString(IDS_COMPMOVEFAILEDTEXT),
    510                              pci->szFileName, newname);
     511                             pci->pszFileName, newname);
    511512              if (rc == MBID_CANCEL)    /* cause loop to break */
    512513                pcin = NULL;
     
    533534                MassMkdir(hwndMain, dirname);
    534535            }
    535             rc = docopyf(COPY, pci->szFileName, "%s", newname);
     536            rc = docopyf(COPY, pci->pszFileName, "%s", newname);
    536537            if (rc) {
    537538              rc = Dos_Error(MB_ENTERCANCEL,
     
    541542                             __LINE__,
    542543                             GetPString(IDS_COMPCOPYFAILEDTEXT),
    543                              pci->szFileName, newname);
     544                             pci->pszFileName, newname);
    544545              if (rc == MBID_CANCEL)
    545546                pcin = NULL;            /* cause loop to break */
     
    551552                WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciO),
    552553                           MPFROM2SHORT(FALSE, CRA_SELECTED));
    553               strcpy(pciO->szFileName, newname);
     554              pciO->pszFileName = xstrdup(newname, pszSrcFile, __LINE__);
    554555              if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR)) {
    555                 pciO->pszFileName = pciO->szFileName + strlen(cmp->leftdir);
     556                pciO->pszFileName = pciO->pszFileName + strlen(cmp->leftdir);
    556557                if (cmp->leftdir[strlen(cmp->leftdir) - 1] != '\\')
    557558                  pciO->pszFileName++;
    558559              }
    559560              else {
    560                 pciO->pszFileName = pciO->szFileName + strlen(cmp->rightdir);
     561                pciO->pszFileName = pciO->pszFileName + strlen(cmp->rightdir);
    561562                if (cmp->rightdir[strlen(cmp->rightdir) - 1] != '\\')
    562563                  pciO->pszFileName++;
    563               }
     564              }
    564565              strcpy(pciO->szDispAttr, pci->szDispAttr);
    565566              pciO->attrFile = pci->attrFile;
     
    573574              pciO->cbFile = pci->cbFile;
    574575              pciO->easize = pci->easize;
    575               *pci->szSubject = 0;
     576              pci->pszSubject = xstrdup(f, pszSrcFile, __LINE__);
    576577              pci->flags = CNRITEM_EXISTS;
    577578              WinSendMsg(hwndCnrS, CM_INVALIDATERECORD, MPFROMP(&pci),
     
    792793      RECORDINSERT ri;
    793794      CHAR *pch;
     795      CHAR fname[CCHMAXPATH];
    794796
    795797      WinCancelShutdown(hmq, TRUE);
     
    10241026        while ((filesl && filesl[l]) || (filesr && filesr[r])) {
    10251027          pcir->hwndCnr = hwndRight;
    1026           pcir->pszFileName = pcir->szFileName;
     1028          //pcir->pszFileName = pcir->szFileName;
    10271029          pcir->rc.pszIcon = pcir->pszFileName;
    10281030          pcir->rc.hptrIcon = (HPOINTER) 0;
    1029           pcir->pszSubject = pcir->szSubject;
    1030           pcir->pszLongname = pcir->szLongname;
     1031          //pcir->pszSubject = pcir->szSubject;
     1032          //pcir->pszLongname = pcir->szLongname;
    10311033          pcir->pszDispAttr = pcir->szDispAttr;
    10321034          pcil->hwndCnr = hwndLeft;
    1033           pcil->pszFileName = pcil->szFileName;
     1035          //pcil->pszFileName = pcil->szFileName;
    10341036          pcil->rc.pszIcon = pcil->pszFileName;
    10351037          pcil->rc.hptrIcon = (HPOINTER) 0;
    10361038          pcil->pszDispAttr = pcil->szDispAttr;
    1037           pcil->pszSubject = pcil->szSubject;
    1038           pcil->pszLongname = pcil->szLongname;
     1039          //pcil->pszSubject = pcil->szSubject;
     1040          //pcil->pszLongname = pcil->szLongname;
    10391041          if ((filesl && filesl[l]) && (filesr && filesr[r])) {
    10401042            x = stricmp(filesl[l]->fname, filesr[r]->fname);
    10411043            if (!x) {
    1042               // Same
    1043               sprintf(pcil->szFileName, "%s%s%s", cmp->leftdir,
     1044                // Same
     1045              sprintf(fname, "%s%s%s", cmp->leftdir,
    10441046                      (cmp->leftdir[strlen(cmp->leftdir) - 1] == '\\') ?
    10451047                      NullStr : "\\", filesl[l]->fname);
    10461048              // pcil->rc.hptrIcon    = hptrFile;
    1047               pcil->pszFileName = pcil->szFileName + lenl;
     1049              pcil->pszFileName = xstrdup((fname + lenl), pszSrcFile, __LINE__);
    10481050              pcil->attrFile = filesl[l]->attrFile;
    10491051              y = 0;
     
    10811083                }
    10821084              }
    1083               sprintf(pcir->szFileName, "%s%s%s", cmp->rightdir,
     1085              sprintf(fname, "%s%s%s", cmp->rightdir,
    10841086                      (cmp->rightdir[strlen(cmp->rightdir) - 1] == '\\') ?
    10851087                      NullStr : "\\", filesr[r]->fname);
    1086               pcir->pszFileName = pcir->szFileName + lenr;
     1088              pcir->pszFileName = xstrdup((fname + lenr), pszSrcFile, __LINE__);
    10871089              pcir->attrFile = filesr[r]->attrFile;
    10881090              // pcir->rc.hptrIcon    = hptrFile;
     
    11161118              pcil->flags |= CNRITEM_EXISTS;
    11171119              pcir->flags |= CNRITEM_EXISTS;
    1118               pch = pcil->szSubject;
     1120              pch = pcil->pszSubject;
    11191121              if (pcil->cbFile + pcil->easize > pcir->cbFile + pcir->easize) {
    11201122                pcil->flags |= CNRITEM_LARGER;
     
    11441146                pcil->flags |= CNRITEM_NEWER;
    11451147                pcir->flags |= CNRITEM_OLDER;
    1146                 if (pch != pcil->szSubject) {
     1148                if (pch != pcil->pszSubject) {
    11471149                  strcpy(pch, ", ");
    11481150                  pch += 2;
     
    11661168                pcil->flags |= CNRITEM_OLDER;
    11671169                pcir->flags |= CNRITEM_NEWER;
    1168                 if (pch != pcil->szSubject) {
     1170                if (pch != pcil->pszSubject) {
    11691171                  strcpy(pch, ", ");
    11701172                  pch += 2;
     
    11791181            else if (x < 0) {
    11801182              // Just on left
    1181               sprintf(pcil->szFileName, "%s%s%s", cmp->leftdir,
     1183              sprintf(fname, "%s%s%s", cmp->leftdir,
    11821184                      (cmp->leftdir[strlen(cmp->leftdir) - 1] == '\\') ?
    11831185                      NullStr : "\\", filesl[l]->fname);
    1184               pcil->pszFileName = pcil->szFileName + lenl;
     1186              pcil->pszFileName = xstrdup((fname + lenl), pszSrcFile, __LINE__);
    11851187              pcil->attrFile = filesl[l]->attrFile;
    11861188              // pcil->rc.hptrIcon    = hptrFile;
     
    12231225            else {
    12241226              // Just on right
    1225               sprintf(pcir->szFileName, "%s%s%s", cmp->rightdir,
     1227              sprintf(fname, "%s%s%s", cmp->rightdir,
    12261228                      (cmp->rightdir[strlen(cmp->rightdir) - 1] == '\\') ?
    12271229                      NullStr : "\\", filesr[r]->fname);
    1228               pcir->pszFileName = pcir->szFileName + lenr;
     1230              pcir->pszFileName = xstrdup((fname + lenr), pszSrcFile, __LINE__);
    12291231              pcir->attrFile = filesr[r]->attrFile;
    12301232              // pcir->rc.hptrIcon    = hptrFile;
     
    12691271          else if (filesl && filesl[l]) {
    12701272            // Just on left
    1271             sprintf(pcil->szFileName, "%s%s%s", cmp->leftdir,
     1273            sprintf(fname, "%s%s%s", cmp->leftdir,
    12721274                    (cmp->leftdir[strlen(cmp->leftdir) - 1] == '\\') ?
    12731275                    NullStr : "\\", filesl[l]->fname);
    1274             pcil->pszFileName = pcil->szFileName + lenl;
     1276            pcil->pszFileName = xstrdup((fname + lenl), pszSrcFile, __LINE__);
    12751277            pcil->attrFile = filesl[l]->attrFile;
    12761278            // pcil->rc.hptrIcon    = hptrFile;
     
    13131315            /* filesr && filesr[r] */
    13141316            // Just on right
    1315             sprintf(pcir->szFileName, "%s%s%s", cmp->rightdir,
     1317            sprintf(fname, "%s%s%s", cmp->rightdir,
    13161318                    (cmp->rightdir[strlen(cmp->rightdir) - 1] == '\\') ?
    13171319                    NullStr : "\\", filesr[r]->fname);
    1318             pcir->pszFileName = pcir->szFileName + lenr;
     1320            pcir->pszFileName = xstrdup((fname + lenr), pszSrcFile, __LINE__);
    13191321            pcir->attrFile = filesr[r]->attrFile;
    13201322            // pcir->rc.hptrIcon    = hptrFile;
     
    16211623      if (pcown) {
    16221624        pci = (PCNRITEM) pcown->pRecord;
    1623         if (pci && (INT) pci != -1 && !*pci->szFileName)
     1625        if (pci && (INT) pci != -1 && !*pci->pszFileName)
    16241626          return MRFROMLONG(TRUE);
    16251627      }
     
    17611763          SetShiftState();
    17621764          if (pci) {
    1763             if ((pci->rc.flRecordAttr & CRA_INUSE) || !*pci->szFileName)
     1765            if ((pci->rc.flRecordAttr & CRA_INUSE) || !*pci->pszFileName)
    17641766              break;
    17651767            WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
     
    17671769            if (pci->attrFile & FILE_DIRECTORY) {
    17681770              if ((shiftstate & (KC_CTRL | KC_SHIFT)) == (KC_CTRL | KC_SHIFT))
    1769                 OpenObject(pci->szFileName, Settings, hwnd);
     1771                OpenObject(pci->pszFileName, Settings, hwnd);
    17701772              else
    1771                 OpenObject(pci->szFileName, Default, hwnd);
     1773                OpenObject(pci->pszFileName, Default, hwnd);
    17721774            }
    17731775            else
    17741776              DefaultViewKeys(hwnd, hwnd, HWND_DESKTOP, NULL,
    1775                               pci->szFileName);
     1777                              pci->pszFileName);
    17761778            WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS,
    17771779                       MPFROMP(pci),
     
    17941796          cmp->hwndCalling = WinWindowFromID(hwnd, SHORT1FROMMP(mp1));
    17951797          if (pci) {
    1796             if (!*pci->szFileName || *cmp->rightlist)
     1798            if (!*pci->pszFileName || *cmp->rightlist)
    17971799              break;
    17981800            id = COMP_MENU;
     
    18421844            pci = (PCNRITEM) pre->pRecord;
    18431845            if (pci) {
    1844               if (!*pci->szFileName) {
     1846              if (!*pci->pszFileName) {
    18451847                if (pci->rc.flRecordAttr & CRA_SELECTED)
    18461848                  WinSendDlgItemMsg(hwnd, SHORT1FROMMP(mp1),
     
    20882090            CHAR *fakelist[3];
    20892091
    2090             fakelist[0] = pci->szFileName;
     2092            fakelist[0] = pci->pszFileName;
    20912093            fakelist[1] = ofile;
    20922094            fakelist[2] = NULL;
     
    21012103            fc.size = sizeof(fc);
    21022104            fc.hwndParent = hwnd;
    2103             strcpy(fc.file1, pci->szFileName);
     2105            strcpy(fc.file1, pci->pszFileName);
    21042106            strcpy(fc.file2, ofile);
    21052107            WinDlgBox(HWND_DESKTOP, hwnd,
     
    21272129          fSelectedAlways = temp;
    21282130          if (pci && !(pci->attrFile & FILE_DIRECTORY)) {
    2129             p = strrchr(pci->szFileName, '\\');
     2131            p = strrchr(pci->pszFileName, '\\');
    21302132            if (p) {
    21312133              p++;
  • trunk/dll/dircnrs.c

    r705 r730  
    932932                            IDS_SELECTFILTERTEXT : IDS_DESELECTFILTERTEXT));
    933933          if (pci && (INT) pci != -1)
    934             strcpy(mask.szMask, pci->szFileName);
     934            strcpy(mask.szMask, pci->pszFileName);
    935935          if (WinDlgBox(HWND_DESKTOP,
    936936                        dcd->hwndCnr,
     
    12581258                         MPFROMSHORT(CRA_CURSORED));
    12591259        if (pci && (INT) pci != -1 &&
    1260             (!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_SLOW)))
    1261           WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->szFileName), MPVOID);
     1260            (!(driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_SLOW)))
     1261          WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->pszFileName), MPVOID);
    12621262        else
    12631263          WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
     
    16381638                         MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
    16391639        if (pci && (INT) pci != -1 &&
    1640             (!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_SLOW)))
    1641           WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->szFileName), MPVOID);
     1640            (!(driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_SLOW)))
     1641          WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->pszFileName), MPVOID);
    16421642        else
    16431643          WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
     
    17681768            static CHAR dirname[CCHMAXPATH];
    17691769
    1770             strcpy(dirname, pci->szFileName);
     1770            strcpy(dirname, pci->pszFileName);
    17711771            MakeValidDir(dirname);
    17721772            StartSeeAll(HWND_DESKTOP, FALSE, dirname);
     
    18121812            DefaultViewKeys(hwnd,
    18131813                            dcd->hwndFrame,
    1814                             dcd->hwndParent, &swp, pci->szFileName);
     1814                            dcd->hwndParent, &swp, pci->pszFileName);
    18151815          }
    18161816        }
     
    18351835            pci = (PCNRITEM) CurrentRecord(hwnd);
    18361836            if (pci && (INT) pci != -1)
    1837               strcpy(newpath, pci->szFileName);
     1837              strcpy(newpath, pci->pszFileName);
    18381838            else
    18391839              strcpy(newpath, dcd->directory);
     
    19991999          pci = (PCNRITEM) CurrentRecord(hwnd);
    20002000          if (pci && (INT) pci != -1) {
    2001             strcpy(path, pci->szFileName);
     2001            strcpy(path, pci->pszFileName);
    20022002            MakeValidDir(path);
    20032003            WinDlgBox(HWND_DESKTOP, hwnd, UndeleteDlgProc, FM3ModHandle,
     
    20342034            pci = (PCNRITEM) CurrentRecord(hwnd);
    20352035            if (pci && !(pci->attrFile & FILE_DIRECTORY)) {
    2036               p = strrchr(pci->szFileName, '\\');
     2036              p = strrchr(pci->pszFileName, '\\');
    20372037              if (p) {
    20382038                p++;
     
    22212221          pci = (PCNRITEM) CurrentRecord(hwnd);
    22222222          if (pci && (INT) pci != -1)
    2223             strcpy(path, pci->szFileName);
     2223            strcpy(path, pci->pszFileName);
    22242224          else
    22252225            strcpy(path, dcd->directory);
     
    22372237          PMMkDir(dcd->hwndParent,
    22382238                  ((pci && (INT) pci != -1) ?
    2239                    pci->szFileName : dcd->directory), FALSE);
     2239                   pci->pszFileName : dcd->directory), FALSE);
    22402240        }
    22412241        break;
     
    25812581
    25822582          if (pci && (INT) pci != -1 && !(pci->flags & RECFLAGS_ENV)) {
    2583             if (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE) {
     2583            if (driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_REMOVABLE) {
    25842584              struct
    25852585              {
     
    25942594              DosError(FERR_DISABLEHARDERR);
    25952595              // fixme
    2596               rc = DosQueryFSInfo(toupper(*pci->szFileName) - '@',
     2596              rc = DosQueryFSInfo(toupper(*pci->pszFileName) - '@',
    25972597                                  FSIL_VOLSER, &volser, sizeof(volser));
    25982598              if (rc) {
    25992599                Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
    26002600                          GetPString(IDS_CANTFINDDIRTEXT),
    2601                           pci->szFileName);
     2601                          pci->pszFileName);
    26022602                DosBeep(250,100);
    2603                 driveserial[toupper(*pci->szFileName) - 'A'] = -1;
     2603                driveserial[toupper(*pci->pszFileName) - 'A'] = -1;
    26042604                UnFlesh(hwnd, pci);
    26052605                PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     
    26082608                if (SHORT2FROMMP(mp1) == CN_COLLAPSETREE &&
    26092609                    !volser.serial ||
    2610                     driveserial[toupper(*pci->szFileName) - 'A'] !=
     2610                    driveserial[toupper(*pci->pszFileName) - 'A'] !=
    26112611                    volser.serial)
    26122612                  UnFlesh(hwnd, pci);
    26132613                if (SHORT2FROMMP(mp1) != CN_COLLAPSETREE ||
    26142614                    (!volser.serial ||
    2615                      driveserial[toupper(*pci->szFileName) - 'A'] !=
     2615                     driveserial[toupper(*pci->pszFileName) - 'A'] !=
    26162616                     volser.serial)) {
    26172617                  if (Flesh(hwnd, pci) &&
     
    26202620                    PostMsg(hwnd, UM_TOPDIR, MPFROMP(pci), MPVOID);
    26212621                }
    2622                 driveserial[toupper(*pci->szFileName) - 'A'] = volser.serial;
     2622                driveserial[toupper(*pci->pszFileName) - 'A'] = volser.serial;
    26232623              }
    26242624            }
     
    27072707                   pci ? NullStr : GetPString(IDS_NOTEXT),
    27082708                   pci ? NullStr : " ",
    2709                    pci ? pci->szFileName : NullStr,
     2709                   pci ? pci->pszFileName : NullStr,
    27102710                   pci ? " " : NullStr,
    27112711                   GetPString((usOperation == DO_COPY) ?
     
    27572757              }
    27582758              if (uso != DO_LINK &&
    2759                   !(driveflags[toupper(*pci->szFileName) - 'A'] &
     2759                  !(driveflags[toupper(*pci->pszFileName) - 'A'] &
    27602760                    DRIVE_NOTWRITEABLE)) {
    27612761
     
    27632763
    27642764                if (!fQuickArcFind &&
    2765                     !(driveflags[toupper(*pci->szFileName) - 'A'] &
     2765                    !(driveflags[toupper(*pci->pszFileName) - 'A'] &
    27662766                      DRIVE_SLOW))
    2767                   info = find_type(pci->szFileName, NULL);
     2767                  info = find_type(pci->pszFileName, NULL);
    27682768                else
    2769                   info = quick_find_type(pci->szFileName, NULL);
     2769                  info = quick_find_type(pci->pszFileName, NULL);
    27702770                if (!info || ((uso == DO_MOVE && !info->move) ||
    27712771                              (uso == DO_COPY && !info->create))) {
     
    30803080              (pci->rc.flRecordAttr & CRA_CURSORED) &&
    30813081              WinQueryActiveWindow(dcd->hwndParent) == dcd->hwndFrame) {
    3082             if (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_SLOW)
     3082            if (driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_SLOW)
    30833083              WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
    30843084            else
    30853085              WinSendMsg(hwndMain,
    3086                          UM_LOADFILE, MPFROMP(pci->szFileName), MPVOID);
     3086                         UM_LOADFILE, MPFROMP(pci->pszFileName), MPVOID);
    30873087          }
    30883088          if (!dcd->suspendview &&
     
    31403140              break;
    31413141            DosError(FERR_DISABLEHARDERR);
    3142             status = DosFindFirst(pci->szFileName,
     3142            status = DosFindFirst(pci->pszFileName,
    31433143                                  &hDir,
    31443144                                  FILE_NORMAL | FILE_DIRECTORY |
     
    31563156                else if ((shiftstate & (KC_CTRL | KC_SHIFT)) ==
    31573157                         (KC_CTRL | KC_SHIFT))
    3158                   OpenObject(pci->szFileName, Settings, dcd->hwndFrame);
     3158                  OpenObject(pci->pszFileName, Settings, dcd->hwndFrame);
    31593159                else if (shiftstate & KC_CTRL)
    3160                   OpenObject(pci->szFileName, Default, dcd->hwndFrame);
     3160                  OpenObject(pci->pszFileName, Default, dcd->hwndFrame);
    31613161                else if (shiftstate & KC_SHIFT) {
    31623162
     
    31663166                                       dcd->hwndParent,
    31673167                                       dcd->hwndFrame,
    3168                                        FALSE, pci->szFileName);
     3168                                       FALSE, pci->pszFileName);
    31693169                  if (hwndDir) {
    31703170                    if (fMinOnOpen)
     
    31803180                else {
    31813181                  strcpy(dcd->previous, dcd->directory);
    3182                   strcpy(dcd->directory, pci->szFileName);
     3182                  strcpy(dcd->directory, pci->pszFileName);
    31833183                  DosEnterCritSec();
    31843184                  dcd->stopflag++;
     
    32103210                DefaultViewKeys(hwnd,
    32113211                                dcd->hwndFrame,
    3212                                 dcd->hwndParent, &swp, pci->szFileName);
     3212                                dcd->hwndParent, &swp, pci->pszFileName);
    32133213                WinSendMsg(hwnd,
    32143214                           CM_SETRECORDEMPHASIS,
     
    32213221            else {
    32223222              if (!*dcd->directory || IsValidDir(dcd->directory)) {
    3223                 NotifyError(pci->szFileName, status);
     3223                NotifyError(pci->pszFileName, status);
    32243224                WinSendMsg(hwnd,
    32253225                           CM_REMOVERECORD,
  • trunk/dll/dirsize.c

    r689 r730  
    9797  RECORDINSERT ri;
    9898  PCNRITEM pCI;
     99  CHAR *f = 0;
    99100
    100101  // fixme to report errors
     
    146147    else
    147148      DosError(FERR_DISABLEHARDERR);
    148     pCI->pszLongname = pCI->szFileName;
     149    pCI->pszLongname = pCI->pszFileName;
    149150    pCI->rc.hptrIcon = hptrDir;
    150     *pCI->szDispAttr = *pCI->szLongname = *pCI->szSubject = 0;
    151     pCI->attrFile = 0L;
     151    *pCI->szDispAttr = 0;
     152    pCI->attrFile = 0;
     153    pCI->pszLongname = xstrdup(f, pszSrcFile, __LINE__);
     154    pCI->pszSubject = xstrdup(f, pszSrcFile, __LINE__);
    152155  }
    153156  else {
     
    162165
    163166  if (strlen(pszFileName) < 4 || top)
    164     strcpy(pCI->szFileName, pszFileName);
     167   pCI->pszFileName = xstrdup(pszFileName, pszSrcFile, __LINE__);
    165168  else {
    166169    p = strrchr(pszFileName, '\\');
     
    170173      p++;
    171174    sp = (strchr(pszFileName, ' ') != NULL) ? "\"" : NullStr;
    172     pp = pCI->szFileName;
     175    pp = pCI->pszFileName;
    173176    if (*sp) {
    174177      *pp = *sp;
     
    180183      strcat(pp, sp);
    181184  }
    182   pCI->pszFileName = pCI->szFileName + strlen(pCI->szFileName);
     185  pCI->pszFileName = pCI->pszFileName + strlen(pCI->pszFileName);
    183186  pCI->rc.pszIcon = pCI->pszLongname;
    184187  pCI->rc.flRecordAttr |= CRA_RECORDREADONLY;
    185188  if (fForceUpper)
    186     strupr(pCI->szFileName);
     189    strupr(pCI->pszFileName);
    187190  else if (fForceLower)
    188     strlwr(pCI->szFileName);
     191    strlwr(pCI->pszFileName);
    189192  memset(&ri, 0, sizeof(RECORDINSERT));
    190193  ri.cb = sizeof(RECORDINSERT);
     
    293296
    294297        memset(&fsa, 0, sizeof(fsa));
    295         rc = DosQueryFSInfo(toupper(*pCI->szFileName) - '@', FSIL_ALLOC, &fsa,
     298        rc = DosQueryFSInfo(toupper(*pCI->pszFileName) - '@', FSIL_ALLOC, &fsa,
    296299                            sizeof(FSALLOCATE));
    297300        if (!rc) {
     
    299302            ((float)fsa.cUnit * (fsa.cSectorUnit * fsa.cbSector));
    300303        }
    301         pCI->szLongname[1] = 1;         // Flag root - hack cough
     304        pCI->pszLongname[1] = 1;                // Flag root - hack cough
    302305      }
    303306      else
     
    319322    CommaFmtULL(szSubDir, sizeof(szSubDir), pCI->easize, 'K');
    320323    CommaFmtULL(szAllDir, sizeof(szAllDir), pCI->cbFile + pCI->easize, 'K');
    321     sprintf(&pCI->szFileName[strlen(pCI->szFileName)],
     324    sprintf(&pCI->pszFileName[strlen(pCI->pszFileName)],
    322325            "  %s + %s = %s (%.02lf%%%s)\r%s",
    323326            szCurDir,
     
    355358  }
    356359  if (pciParent) {
    357     p = strchr(pciParent->szFileName, '\r');
     360    p = strchr(pciParent->pszFileName, '\r');
    358361    if (p)
    359362      *p = 0;
    360363    fprintf(fp, "%*.*s%s %lu %s%s\n",
    361364            indent * 2, indent * 2, " ",
    362             pciParent->szFileName,
     365            pciParent->pszFileName,
    363366            pciParent->attrFile,
    364367            GetPString(IDS_FILETEXT), &"s"[pciParent->attrFile == 1]);
     
    588591            LONG clr, x;
    589592
    590             p = strchr(pci->szFileName, '\r');
     593            p = strchr(pci->pszFileName, '\r');
    591594            if (p) {
    592595              /* draw text */
     
    600603              GpiSetMix(oi->hps, FM_OVERPAINT);
    601604              *p = 0;
    602               GpiQueryTextBox(oi->hps, strlen(pci->szFileName),
    603                               pci->szFileName, TXTBOX_COUNT, aptl);
     605              GpiQueryTextBox(oi->hps, strlen(pci->pszFileName),
     606                              pci->pszFileName, TXTBOX_COUNT, aptl);
    604607              ptl.x = oi->rclItem.xLeft;
    605608              ptl.y = (oi->rclItem.yTop - aptl[TXTBOX_TOPRIGHT].y);
    606609              GpiMove(oi->hps, &ptl);
    607               GpiCharString(oi->hps, strlen(pci->szFileName),
    608                             pci->szFileName);
     610              GpiCharString(oi->hps, strlen(pci->pszFileName),
     611                            pci->pszFileName);
    609612              *p = '\r';
    610613
     
    663666              /* fill box with graph bar, flags is integer % */
    664667              if (pci->flags) {
    665                 if (pci->szLongname[1] == 1)    /* is root record */
     668                if (*(pci->pszLongname + 1) == 1)       /* is root record */
    666669                  GpiSetColor(oi->hps, CLR_DARKGREEN);
    667670                else
     
    675678
    676679                /* draw highlights and shadows on graph */
    677                 if (pci->szLongname[1] == 1)
     680                if (*(pci->pszLongname + 1) == 1)
    678681                  GpiSetColor(oi->hps, CLR_GREEN);
    679682                else
     
    692695                ptl.x = oi->rclItem.xLeft + pci->flags;
    693696                GpiLine(oi->hps, &ptl);
    694                 if (pci->szLongname[1] != 1) {
     697                if (*(pci->pszLongname + 1) != 1) {
    695698                  GpiSetColor(oi->hps, CLR_DARKRED);
    696699                  ptl.x = oi->rclItem.xLeft + 2;
     
    752755          while (pci && (INT) pci != -1) {
    753756            memset(szTemp, 0, sizeof(szTemp));
    754             strncpy(szTemp, pci->szFileName,
    755                     pci->pszFileName - pci->szFileName);
     757            strncpy(szTemp, pci->pszFileName,
     758                    pci->pszFileName - pci->pszFileName);
    756759            strrev(szTemp);
    757760            if (*pszFileName && *szTemp != '\\')
  • trunk/dll/draglist.c

    r727 r730  
    256256  while (pci && (INT) pci > -1) {
    257257    if (!(pci->rc.flRecordAttr & CRA_FILTERED)) {
    258       if (IsRoot(pci->szFileName) && !IsValidDrive(*pci->szFileName))
     258      if (IsRoot(pci->pszFileName) && !IsValidDrive(*pci->pszFileName))
    259259        goto Continuing;
    260260      if (!arcfile) {
    261         strcpy(szBuffer, pci->szFileName);
     261        strcpy(szBuffer, pci->pszFileName);
    262262        p = strrchr(szBuffer, '\\');
    263263        if (p) {
     
    270270      }
    271271      else
    272         strcpy(szFile, pci->szFileName);
     272        strcpy(szFile, pci->pszFileName);
    273273    }
    274274    if (!arcfile) {
     
    369369      }
    370370      pDItem->fsControl = isdir ? DC_CONTAINER : 0;
    371       if (IsFullName(pci->szFileName) &&
    372           (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE))
     371      if (IsFullName(pci->pszFileName) &&
     372          (driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_REMOVABLE))
    373373        pDItem->fsControl |= DC_REMOVEABLEMEDIA;
    374374      pDItem->fsSupportedOps = DO_COPYABLE | DO_LINKABLE;
    375       if (moveok && IsFullName(pci->szFileName) &&
    376           !(driveflags[toupper(*pci->szFileName) - 'A'] &
     375      if (moveok && IsFullName(pci->pszFileName) &&
     376          !(driveflags[toupper(*pci->pszFileName) - 'A'] &
    377377            DRIVE_NOTWRITEABLE))
    378378        pDItem->fsSupportedOps |= DO_MOVEABLE;
    379       if (IsRoot(pci->szFileName)) {
     379      if (IsRoot(pci->pszFileName)) {
    380380        pDItem->fsSupportedOps = DO_LINKABLE;
    381381        rooting = TRUE;
     
    774774                       MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_SELECTED));
    775775    }
    776     while (pci && (INT) pci != -1 && *pci->szFileName) {
     776    while (pci && (INT) pci != -1 && *pci->pszFileName) {
    777777      if (pdinfoOld || DrgQueryDragStatus() & DGS_LAZYDRAGINPROGRESS) {
    778778        if (!pdinfoOld)
     
    787787        pdinfoCurrent = pdinfoOld = DrgAllocDraginfo(1);
    788788      if (pdinfoCurrent) {
    789         strcpy(szDir, pci->szFileName);
     789        strcpy(szDir, pci->pszFileName);
    790790        p = szDir;
    791791        while (*p) {
     
    802802        }
    803803        else {
    804           strcpy(szFile, pci->szFileName);
     804          strcpy(szFile, pci->pszFileName);
    805805          *szDir = 0;
    806806        }
     
    818818        ditem.hstrTargetName = DrgAddStrHandle(szFile);
    819819        ditem.fsControl = 0;
    820         if (IsRoot(pci->szFileName) || (pci->attrFile & FILE_DIRECTORY) != 0)
     820        if (IsRoot(pci->pszFileName) || (pci->attrFile & FILE_DIRECTORY) != 0)
    821821          ditem.fsControl |= DC_CONTAINER;
    822         if (IsFullName(pci->szFileName) &&
    823             (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE))
     822        if (IsFullName(pci->pszFileName) &&
     823            (driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_REMOVABLE))
    824824          ditem.fsControl |= DC_REMOVEABLEMEDIA;
    825825        ditem.fsSupportedOps = DO_COPYABLE | DO_LINKABLE;
    826         if (IsFullName(pci->szFileName) &&
    827             !(driveflags[toupper(*pci->szFileName) - 'A'] &
     826        if (IsFullName(pci->pszFileName) &&
     827            !(driveflags[toupper(*pci->pszFileName) - 'A'] &
    828828              DRIVE_NOTWRITEABLE))
    829829          ditem.fsSupportedOps |= DO_MOVEABLE;
    830         if (IsRoot(pci->szFileName))
     830        if (IsRoot(pci->pszFileName))
    831831          ditem.fsSupportedOps = DO_LINKABLE;
    832832        memset(&dimgFakeIcon, 0, sizeof(DRAGIMAGE));
     
    839839        dimgFakeIcon.cxOffset = -16;
    840840        dimgFakeIcon.cyOffset = 0;
    841         if (IsFullName(pci->szFileName) &&
    842             (driveflags[toupper(*pci->szFileName) - 'A'] &
     841        if (IsFullName(pci->pszFileName) &&
     842            (driveflags[toupper(*pci->pszFileName) - 'A'] &
    843843             DRIVE_NOTWRITEABLE))
    844844          pdinfoCurrent->usOperation = DO_COPY;
    845845        else
    846846          pdinfoCurrent->usOperation = DO_DEFAULT;
    847         if (IsRoot(pci->szFileName))
     847        if (IsRoot(pci->pszFileName))
    848848          pdinfoCurrent->usOperation = DO_LINK;
    849849        pdinfoCurrent->hwndSource = (hwndObj) ? hwndObj : hwndCnr;
  • trunk/dll/droplist.c

    r688 r730  
    468468        strcpy(li->targetpath, directory);
    469469      else if (pci)
    470         strcpy(li->targetpath, pci->szFileName);
     470        strcpy(li->targetpath, pci->pszFileName);
    471471      if (isArc) {
    472472        strcpy(li->arcname, szArc);
  • trunk/dll/eas.c

    r729 r730  
    1616  22 Mar 07 GKY Use QWL_USER
    1717  05 Jul 07 SHL GetFileEAs: avoid heap corruption
     18  15 Jul 07 GKY Allow subject edit of up to 256 chars
    1819
    1920***********************************************************************/
  • trunk/dll/filldir.c

    r705 r730  
    176176  UINT y;
    177177  UINT t;
     178  CHAR *f = 0;
    178179
    179180  pci->hwndCnr = hwndCnr;
    180181  t = strlen(pszDirectory);
    181   memcpy(pci->szFileName, pszDirectory, t + 1);
     182  pci->pszFileName = xstrdup(pszDirectory, pszSrcFile, __LINE__);
    182183  /* note!  we cheat below, and accept the full pathname in pszDirectory
    183184     if !*pffb->achName.  speeds up and simplifies processing elsewhere
     
    185186   */
    186187  if (*pffb->achName) {
    187     p = pci->szFileName + (t - 1);
     188    p = pci->pszFileName + (t - 1);
    188189    if (*p != '\\') {
    189190      p++;
     
    196197  if (pffb->cbList > 4L &&
    197198      dcd && fLoadSubject &&
    198       (isalpha(*pci->szFileName) &&
    199        !(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLOADSUBJS))) {
     199      (isalpha(*pci->pszFileName) &&
     200       !(driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_NOLOADSUBJS))) {
    200201    APIRET rc;
    201202    EAOP2 eaop;
     
    219220        eaop.fpFEA2List = pfealist;
    220221        eaop.oError = 0;
    221         rc = DosQueryPathInfo(pci->szFileName, FIL_QUERYEASFROMLIST,
     222        rc = DosQueryPathInfo(pci->pszFileName, FIL_QUERYEASFROMLIST,
    222223                              (PVOID) & eaop, (ULONG) sizeof(EAOP2));
    223224        if (!rc) {
     
    226227          value[pfea->cbValue] = 0;
    227228          if (*(USHORT *) value == EAT_ASCII)
    228             strncpy(pci->szSubject, value + (sizeof(USHORT) * 2), 39);
    229           pci->szSubject[39] = 0;
     229            pci->pszSubject = xstrdup(value + (sizeof(USHORT) * 2), pszSrcFile, __LINE__);
    230230        }
    231231        free(pfealist);
     
    234234    }
    235235  }
    236   pci->pszSubject = pci->szSubject;
    237236  /* load the object's longname */
    238   *pci->szLongname = 0;
     237  pci->pszLongname = xstrdup(f, pszSrcFile, __LINE__);
    239238  if (fLoadLongnames &&
    240239      dcd &&
    241240      pffb->cbList > 4L &&
    242       isalpha(*pci->szFileName) &&
    243       ~driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLONGNAMES &&
    244       ~driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLOADLONGS) {
     241      isalpha(*pci->pszFileName) &&
     242      ~driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_NOLONGNAMES &&
     243      ~driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_NOLOADLONGS) {
    245244    APIRET rc;
    246245    EAOP2 eaop;
     
    264263        eaop.fpFEA2List = pfealist;
    265264        eaop.oError = 0;
    266         rc = DosQueryPathInfo(pci->szFileName, FIL_QUERYEASFROMLIST,
     265        rc = DosQueryPathInfo(pci->pszFileName, FIL_QUERYEASFROMLIST,
    267266                              (PVOID) & eaop, (ULONG) sizeof(EAOP2));
    268267        if (!rc) {
     
    271270          value[pfea->cbValue] = 0;
    272271          if (*(USHORT *) value == EAT_ASCII)
    273             strncpy(pci->szLongname, value + (sizeof(USHORT) * 2),
    274                     CCHMAXPATHCOMP);
    275           pci->szLongname[CCHMAXPATHCOMP - 1] = 0;
     272            pci->pszLongname = xstrdup(value + (sizeof(USHORT) * 2), pszSrcFile, __LINE__);
    276273        }
    277274        free(pfealist);
     
    280277    }
    281278  }
    282   pci->pszLongname = pci->szLongname;
    283 
    284279  /* do anything required to case of filename */
    285280  if (fForceUpper)
    286     strupr(pci->szFileName);
     281    strupr(pci->pszFileName);
    287282  else if (fForceLower)
    288     strlwr(pci->szFileName);
     283    strlwr(pci->pszFileName);
    289284
    290285  /* get an icon to use with it */
     
    292287    // is directory
    293288    if (fNoIconsDirs ||
    294         (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLOADICONS) ||
    295         !isalpha(*pci->szFileName)) {
     289        (driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_NOLOADICONS) ||
     290        !isalpha(*pci->pszFileName)) {
    296291      hptr = (HPOINTER) 0;
    297292    }
    298293    else
    299       hptr = WinLoadFileIcon(pci->szFileName, FALSE);
     294      hptr = WinLoadFileIcon(pci->pszFileName, FALSE);
    300295  }
    301296  else {
    302297    // is file
    303298    if (fNoIconsFiles ||
    304         (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLOADICONS) ||
    305         !isalpha(*pci->szFileName)) {
     299        (driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_NOLOADICONS) ||
     300        !isalpha(*pci->pszFileName)) {
    306301      hptr = (HPOINTER) 0;
    307302    }
    308303    else
    309       hptr = WinLoadFileIcon(pci->szFileName, FALSE);
     304      hptr = WinLoadFileIcon(pci->pszFileName, FALSE);
    310305
    311306    if (!hptr || IsDefaultIcon(hptr))
    312       hptr = IDFile(pci->szFileName);
     307      hptr = IDFile(pci->pszFileName);
    313308  }
    314309
     
    324319  /* decide where to point for the container's title text */
    325320  if (partial) {
    326     p = strrchr(pci->szFileName, '\\');
     321    p = strrchr(pci->pszFileName, '\\');
    327322    if (!p) {
    328       p = strrchr(pci->szFileName, ':');
     323      p = strrchr(pci->pszFileName, ':');
    329324      if (!p)
    330         p = pci->szFileName;
     325        p = pci->pszFileName;
    331326      else
    332327        p++;
     
    337332    }
    338333    if (!*p)
    339       p = pci->szFileName;
     334      p = pci->pszFileName;
    340335  }
    341336  else
    342     p = pci->szFileName;
     337    p = pci->pszFileName;
    343338  /* now fill the darned thing in... */
    344339  pci->pszFileName = p;
     
    411406  register INT x;
    412407  register INT y;
     408  CHAR *f = 0;
    413409
    414410  /* fill in a container record from a FILESTATUS4 structure */
    415411
    416412  pci->hwndCnr = hwndCnr;
    417   strcpy(pci->szFileName, pszFileName);
     413  pci->pszFileName = xstrdup(pszFileName, pszSrcFile, __LINE__);
    418414  /* load the object's Subject, if required */
    419415  if (pfsa4->cbList > 4L &&
    420416      dcd &&
    421417      fLoadSubject &&
    422       (!isalpha(*pci->szFileName) ||
    423        !(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLOADSUBJS))) {
     418      (!isalpha(*pci->pszFileName) ||
     419       !(driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_NOLOADSUBJS))) {
    424420    APIRET rc;
    425421    EAOP2 eaop;
     
    443439        eaop.fpFEA2List = pfealist;
    444440        eaop.oError = 0;
    445         rc = DosQueryPathInfo(pci->szFileName, FIL_QUERYEASFROMLIST,
     441        rc = DosQueryPathInfo(pci->pszFileName, FIL_QUERYEASFROMLIST,
    446442                              (PVOID) & eaop, (ULONG) sizeof(EAOP2));
    447443        if (!rc) {
     
    450446          value[pfea->cbValue] = 0;
    451447          if (*(USHORT *) value == EAT_ASCII)
    452             strncpy(pci->szSubject, value + (sizeof(USHORT) * 2), 39);
    453           pci->szSubject[39] = 0;
     448            pci->pszSubject = xstrdup(value + (sizeof(USHORT) * 2), pszSrcFile, __LINE__);
    454449        }
    455450        free(pfealist);
     
    458453    }
    459454  }
    460   pci->pszSubject = pci->szSubject;
    461   *pci->szLongname = 0;
     455  pci->pszLongname = xstrdup(f, pszSrcFile, __LINE__);
    462456  if (fLoadLongnames &&
    463457      dcd &&
    464458      pfsa4->cbList > 4L &&
    465       isalpha(*pci->szFileName) &&
    466       ~driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLONGNAMES &&
    467       ~driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLOADLONGS) {
     459      isalpha(*pci->pszFileName) &&
     460      ~driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_NOLONGNAMES &&
     461      ~driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_NOLOADLONGS) {
    468462    APIRET rc;
    469463    EAOP2 eaop;
     
    487481        eaop.fpFEA2List = pfealist;
    488482        eaop.oError = 0;
    489         rc = DosQueryPathInfo(pci->szFileName, FIL_QUERYEASFROMLIST,
     483        rc = DosQueryPathInfo(pci->pszFileName, FIL_QUERYEASFROMLIST,
    490484                              (PVOID) & eaop, (ULONG) sizeof(EAOP2));
    491485        if (!rc) {
     
    494488          value[pfea->cbValue] = 0;
    495489          if (*(USHORT *) value == EAT_ASCII)
    496             strncpy(pci->szLongname, value + (sizeof(USHORT) * 2),
    497                     CCHMAXPATHCOMP);
    498           pci->szLongname[CCHMAXPATHCOMP - 1] = 0;
     490            pci->pszLongname = xstrdup(value + (sizeof(USHORT) * 2), pszSrcFile, __LINE__);
    499491        }
    500492        free(pfealist);
     
    503495    }
    504496  }
    505   pci->pszLongname = pci->szLongname;
    506497  if (fForceUpper)
    507     strupr(pci->szFileName);
     498    strupr(pci->pszFileName);
    508499  else if (fForceLower)
    509     strlwr(pci->szFileName);
     500    strlwr(pci->pszFileName);
    510501
    511502  if (pfsa4->attrFile & FILE_DIRECTORY) {
    512503    if (fNoIconsDirs ||
    513         (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLOADICONS) ||
    514         !isalpha(*pci->szFileName)) {
     504        (driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_NOLOADICONS) ||
     505        !isalpha(*pci->pszFileName)) {
    515506      hptr = (HPOINTER) 0;
    516507    }
    517508    else
    518       hptr = WinLoadFileIcon(pci->szFileName, FALSE);
     509      hptr = WinLoadFileIcon(pci->pszFileName, FALSE);
    519510  }
    520511  else {
    521512    if (fNoIconsFiles ||
    522         (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLOADICONS) ||
    523         !isalpha(*pci->szFileName)) {
    524       hptr = IDFile(pci->szFileName);
     513        (driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_NOLOADICONS) ||
     514        !isalpha(*pci->pszFileName)) {
     515      hptr = IDFile(pci->pszFileName);
    525516    }
    526517    else
    527       hptr = WinLoadFileIcon(pci->szFileName, FALSE);
     518      hptr = WinLoadFileIcon(pci->pszFileName, FALSE);
    528519  }
    529520  if (!hptr) {
     
    537528
    538529  if (partial) {
    539     p = strrchr(pci->szFileName, '\\');
     530    p = strrchr(pci->pszFileName, '\\');
    540531    if (!p) {
    541       p = strrchr(pci->szFileName, ':');
     532      p = strrchr(pci->pszFileName, ':');
    542533      if (!p)
    543         p = pci->szFileName;
     534        p = pci->pszFileName;
    544535      else
    545536        p++;
     
    549540      p++;
    550541    if (!*p)
    551       p = pci->szFileName;
     542      p = pci->pszFileName;
    552543  }
    553544  else
    554     p = pci->szFileName;
     545    p = pci->pszFileName;
    555546  pci->pszFileName = p;
    556547  pci->date.day = pfsa4->fdateLastWrite.day;
     
    10751066
    10761067            pci->rc.flRecordAttr |= CRA_RECORDREADONLY;
    1077             if ((ULONG) (toupper(*pci->szFileName) - '@') == ulDriveNum)
     1068            if ((ULONG) (toupper(*pci->pszFileName) - '@') == ulDriveNum)
    10781069              pci->rc.flRecordAttr |= (CRA_CURSORED | CRA_SELECTED);
    10791070
     
    10971088                }
    10981089                sprintf(suggest + strlen(suggest), "%c" , toupper(*szDrive));
    1099                 strcpy(pci->szFileName, szDrive);
    1100                 pci->pszFileName = pci->szFileName;
     1090                pci->pszFileName = xstrdup(szDrive, pszSrcFile, __LINE__);
    11011091                pci->rc.pszIcon = pci->pszFileName;
    11021092                pci->attrFile = FILE_DIRECTORY;
     
    11091099            }
    11101100            else {
    1111               strcpy(pci->szFileName, szDrive);
    1112               pci->pszFileName = pci->szFileName;
     1101              pci->pszFileName = xstrdup(szDrive, pszSrcFile, __LINE__);
    11131102              pci->rc.pszIcon = pci->pszFileName;
    11141103              pci->attrFile = FILE_DIRECTORY;
     
    11201109          else {
    11211110            pci->rc.hptrIcon = hptrDunno;
    1122             strcpy(pci->szFileName, szDrive);
    1123             pci->pszFileName = pci->szFileName;
     1111            pci->pszFileName = xstrdup(szDrive, pszSrcFile, __LINE__);
    11241112            pci->rc.pszIcon = pci->pszFileName;
    11251113            pci->attrFile = FILE_DIRECTORY;
     
    11311119        else {
    11321120          pci->rc.hptrIcon = hptrFloppy;
    1133           strcpy(pci->szFileName, szDrive);
    1134           pci->pszFileName = pci->szFileName;
     1121          pci->pszFileName = xstrdup(szDrive, pszSrcFile, __LINE__);
    11351122          pci->rc.pszIcon = pci->pszFileName;
    11361123          pci->attrFile = FILE_DIRECTORY;
     
    11731160                                  MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
    11741161      while (pci && (INT) pci != -1) {
    1175         if ((ULONG) (toupper(*pci->szFileName) - '@') == ulDriveNum) {
     1162        if ((ULONG) (toupper(*pci->pszFileName) - '@') == ulDriveNum) {
    11761163          WinSendMsg(hwndCnr,
    11771164                     CM_SETRECORDEMPHASIS,
     
    12001187      if (pciParent) {
    12011188        pciParent->flags |= RECFLAGS_ENV;
    1202         strcpy(pciParent->szFileName, GetPString(IDS_ENVVARSTEXT));
    1203         pciParent->pszFileName = pciParent->szFileName;
     1189        pciParent->pszFileName = xstrdup(GetPString(IDS_ENVVARSTEXT), pszSrcFile, __LINE__);
     1190        //pciParent->pszFileName = pciParent->szFileName;
    12041191        pciParent->rc.hptrIcon = hptrEnv;
    12051192        pciParent->rc.pszIcon = pciParent->pszFileName;
     
    12351222                               MPFROMLONG(EXTRA_RECORD_BYTES2),
    12361223                               MPFROMLONG(1));
    1237               if (pci) {
    1238                 pci->flags |= RECFLAGS_ENV;
    1239                 sprintf(pci->szFileName, "%%%s%%", FileSystem);
    1240                 pci->pszFileName = pci->szFileName;
     1224              if (pci) {
     1225                CHAR fname[CCHMAXPATH];
     1226                pci->flags |= RECFLAGS_ENV;
     1227                sprintf(fname, "%%%s%%", FileSystem);
     1228                pci->pszFileName = xstrdup(fname, pszSrcFile, __LINE__);
    12411229                pci->rc.hptrIcon = hptrEnv;
    12421230                pci->rc.pszIcon = pci->pszFileName;
     
    12831271                                      MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
    12841272      if (!(pci->flags & RECFLAGS_ENV)) {
    1285         if ((ULONG) (toupper(*pci->szFileName) - '@') == ulDriveNum ||
    1286             toupper(*pci->szFileName) > 'B') {
    1287           if (!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_INVALID)
    1288               && !(driveflags[toupper(*pci->szFileName) - 'A'] &
     1273        if ((ULONG) (toupper(*pci->pszFileName) - '@') == ulDriveNum ||
     1274            toupper(*pci->pszFileName) > 'B') {
     1275          if (!(driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_INVALID)
     1276              && !(driveflags[toupper(*pci->pszFileName) - 'A'] &
    12891277                   DRIVE_NOPRESCAN) && (!fNoRemovableScan
    12901278                                        ||
    12911279                                        !(driveflags
    1292                                           [toupper(*pci->szFileName) -
     1280                                          [toupper(*pci->pszFileName) -
    12931281                                           'A'] & DRIVE_REMOVABLE))) {
    12941282            if (!Stubby(hwndCnr, pci) && !DRIVE_RAMDISK) {
     
    13121300                   LM_INSERTITEM,
    13131301                   MPFROM2SHORT(LIT_SORTASCENDING, 0),
    1314                    MPFROMP(pci->szFileName));
     1302                   MPFROMP(pci->pszFileName));
    13151303      }
    13161304    SkipBadRec:
  • trunk/dll/filter.c

    r574 r730  
    5656  if (mask) {
    5757    r = (PCNRITEM) rmini;
    58     if (!r->szFileName[3]
     58    if (!(*(r->pszFileName + 3))
    5959        || (mask->fShowDirs && (r->attrFile & FILE_DIRECTORY)))
    6060      return TRUE;
     
    7676      return FALSE;
    7777    if (*mask->szMask) {
    78       file = strrchr(r->szFileName, '\\');
     78      file = strrchr(r->pszFileName, '\\');
    7979      if (!file)
    80         file = strrchr(r->szFileName, ':');
     80        file = strrchr(r->pszFileName, ':');
    8181      if (file)
    8282        file++;
    8383      else
    84         file = r->szFileName;
     84        file = r->pszFileName;
    8585      if (mask->pszMasks[1]) {
    8686        for (x = 0; mask->pszMasks[x]; x++) {
     
    8989              if (wildcard((strchr(mask->pszMasks[x], '\\') ||
    9090                            strchr(mask->pszMasks[x], ':')) ?
    91                            r->szFileName : file, mask->pszMasks[x], FALSE))
     91                           r->pszFileName : file, mask->pszMasks[x], FALSE))
    9292                ret = TRUE;
    9393            }
     
    9595              if (wildcard((strchr(mask->pszMasks[x], '\\') ||
    9696                            strchr(mask->pszMasks[x], ':')) ?
    97                            r->szFileName : file, mask->pszMasks[x] + 1,
     97                           r->pszFileName : file, mask->pszMasks[x] + 1,
    9898                           FALSE)) {
    9999                ret = FALSE;
     
    107107        if (wildcard((strchr(mask->szMask, '\\') ||
    108108                      strchr(mask->szMask, ':')) ?
    109                      r->szFileName : file, mask->szMask, FALSE))
     109                     r->pszFileName : file, mask->szMask, FALSE))
    110110          ret = TRUE;
    111111      }
  • trunk/dll/findrec.c

    r689 r730  
    4949    if (!noenv || (pci->flags & (RECFLAGS_ENV | RECFLAGS_UNDERENV)) == 0) {
    5050      if (!partmatch) {                 /* full name must match full name */
    51         if (!stricmp(pci->szFileName, filename))
     51        if (!stricmp(pci->pszFileName, filename))
    5252          return pci;                   /* success */
    5353      }
    5454      else {                            /* only root name must match */
    55         if (strlen(pci->szFileName) > 3) {
    56           p = strrchr(pci->szFileName, '\\');
     55        if (strlen(pci->pszFileName) > 3) {
     56          p = strrchr(pci->pszFileName, '\\');
    5757          if (!p) {
    58             p = strrchr(pci->szFileName, ':');
     58            p = strrchr(pci->pszFileName, ':');
    5959            if (p)
    6060              p++;
    6161            else
    62               p = pci->szFileName;
     62              p = pci->pszFileName;
    6363          }
    6464          else
     
    6666        }
    6767        else
    68           p = pci->szFileName;
     68          p = pci->pszFileName;
    6969        if (!stricmp(p, file))
    7070          return pci;                   /* success */
  • trunk/dll/flesh.c

    r574 r730  
    5252    return FALSE;
    5353
    54   strcpy(path, pciParent->szFileName + 1);
     54  strcpy(path, pciParent->pszFileName + 1);
    5555  if (stricmp(path, GetPString(IDS_ENVVARSTEXT) + 1))
    5656    UnFlesh(hwndCnr, pciParent);
     
    105105                                MPFROMLONG(1));
    106106              if (pciL) {
    107                 strcpy(pciL->szFileName, fullpath);
    108                 pciL->pszFileName = pciL->szFileName;
    109                 pciL->rc.pszIcon = pciL->pszFileName;
     107                pciL->pszFileName = xstrdup(fullpath, pszSrcFile, __LINE__);
     108                pciL->rc.pszIcon = pciL->pszFileName;
    110109                if (!fNoIconsDirs &&
    111110                    (!isalpha(*fullpath) ||
     
    165164                               MPFROMP(pciParent),
    166165                               MPFROM2SHORT(CMA_FIRSTCHILD, CMA_ITEMORDER));
    167   if (!pciL || !*pciL->szFileName) {
     166  if (!pciL || !*pciL->pszFileName) {
    168167    if (pciL && (INT) pciL != -1) {
    169168      WinSendMsg(hwndCnr,
     
    173172    if (dcd && dcd->size != sizeof(DIRCNRDATA))
    174173      dcd = NULL;
    175     if (driveflags[toupper(*pciParent->szFileName) - 'A'] &
     174    if (driveflags[toupper(*pciParent->pszFileName) - 'A'] &
    176175        DRIVE_INCLUDEFILES)
    177176      includefiles = TRUE;
    178177    ProcessDirectory(hwndCnr,
    179178                     pciParent,
    180                      pciParent->szFileName,
     179                     pciParent->pszFileName,
    181180                     includefiles, TRUE, TRUE, NULL, dcd, NULL, NULL);
    182181  }
     
    234233  ULONG ddepth = 3L;
    235234  static BOOL brokenlan = FALSE, isbroken = FALSE;
    236 
    237   if (!pciParent || !*pciParent->szFileName || !hwndCnr)
    238     return FALSE;
    239 
    240   len = strlen(pciParent->szFileName);
    241   memcpy(str, pciParent->szFileName, len + 1);
     235  CHAR *f = 0;
     236
     237  if (!pciParent || !*pciParent->pszFileName || !hwndCnr)
     238    return FALSE;
     239
     240  len = strlen(pciParent->pszFileName);
     241  memcpy(str, pciParent->pszFileName, len + 1);
    242242  if (str[len - 1] != '\\')
    243243    str[len++] = '\\';
     
    337337                                                     &nm))));
    338338    DosFindClose(hDir);
    339     if (toupper(*pciParent->szFileName) > 'B' &&
    340         pciParent->szFileName[1] == ':' &&
    341         pciParent->szFileName[2] == '\\' && !pciParent->szFileName[3]) {
     339    if (toupper(*pciParent->pszFileName) > 'B' &&
     340        (*(pciParent->pszFileName + 1)) == ':' &&
     341        (*(pciParent->pszFileName + 2)) == '\\' && !(*(pciParent->pszFileName + 3))) {
    342342
    343343      CHAR s[132];
     
    345345      sprintf(s,
    346346              GetPString(IDS_NOSUBDIRSTEXT),
    347               total, toupper(*pciParent->szFileName));
     347              total, toupper(*pciParent->pszFileName));
    348348      if (rc && rc != ERROR_NO_MORE_FILES)
    349349        sprintf(&s[strlen(s)], GetPString(IDS_SEARCHERRORTEXT), rc, str);
     
    422422        else {
    423423          RECORDINSERT ri;
    424 
    425           *pci->szFileName = 0;
    426           pci->pszFileName = pci->szFileName;
     424          pci->pszFileName = xstrdup(f, pszSrcFile, __LINE__);
     425          //pci->pszFileName = pci->szFileName;
    427426          pci->rc.pszIcon = pci->pszFileName;
    428427          memset(&ri, 0, sizeof(RECORDINSERT));
     
    461460                GetPString(IDS_NOSUBDIRS2TEXT),
    462461                nm,
    463                 toupper(*pciParent->szFileName),
     462                toupper(*pciParent->pszFileName),
    464463                (isremote) ? GetPString(IDS_NOSUBDIRS3TEXT) : NullStr);
    465464        Notify(s);
  • trunk/dll/fm3dll.h

    r697 r730  
    406406  HWND hwndCnr;                 /* The container holding this record */
    407407  PSZ pszFileName;              // Points to szFileName  - required by CFA_STRING
    408   CHAR szFileName[CCHMAXPATH];  // Path name - fixme to rename to szPathName?
    409   CHAR szSubject[40];           /* Subject string */
     408  //CHAR szFileName[CCHMAXPATH];        // Path name - fixme to rename to szPathName?
     409  //CHAR szSubject[40];         /* Subject string */
    410410  CHAR *pszSubject;             // Points szSubject - required by CFA_STRING
    411411  CHAR *pszDispAttr;            // Points to szDispAttr - required by CFA_STRING
     
    422422  ULONG attrFile;               /* Attributes of this file */
    423423  ULONG flags;
    424   CHAR szLongname[1];           // Holds .LONGNAME EA or root flag
     424  //CHAR szLongname[1];         // Holds .LONGNAME EA or root flag
    425425}
    426426CNRITEM, *PCNRITEM;
  • trunk/dll/fm3res.rc

    r728 r730  
    2424  17 Feb 07 GKY Additional drive type icons
    2525  15 Jun 07 SHL Update for OpenWatcom
     26  05 Jul 07 GKY Fix menu removals for WORKPLACE_PROCESS=YES
    2627
    2728***********************************************************************/
  • trunk/dll/info.c

    r689 r730  
    776776          WinEnableWindow(WinWindowFromID(hwnd, FLE_ISARCHIVE), TRUE);
    777777          WinEnableWindow(WinWindowFromID(hwnd, FLE_BINARY), TRUE);
    778           fp = _fsopen(pfs->szFileName, "rb", SH_DENYNO);
     778          fp = _fsopen(pfs->szFileName, "rb", SH_DENYNO);
    779779          if (fp) {
    780780            char buff[512];
  • trunk/dll/mainwnd.c

    r690 r730  
    328328      }
    329329      if (pci && (INT) pci != -1) {
    330         strcpy(ret, pci->szFileName);
     330        strcpy(ret, pci->pszFileName);
    331331        MakeValidDir(ret);
    332332      }
     
    40754075                   MPFROMSHORT(CRA_CURSORED));
    40764076      if (pci && (INT) pci != -1) {
    4077         strcpy(wa.szCurrentPath1, pci->szFileName);
     4077        strcpy(wa.szCurrentPath1, pci->pszFileName);
    40784078        MakeValidDir(wa.szCurrentPath1);
    40794079      }
     
    44874487                                    MPFROMSHORT(CRA_CURSORED));
    44884488      if (pci && (INT) pci != -1) {
    4489         strcpy(path, pci->szFileName);
     4489        strcpy(path, pci->pszFileName);
    44904490        MakeValidDir(path);
    44914491      }
     
    45534553                                        MPFROMSHORT(CRA_CURSORED));
    45544554            if (pci && (INT) pci != -1 &&
    4555                 (!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_SLOW)))
     4555                (!(driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_SLOW)))
    45564556              WinSendMsg(hwnd,
    45574557                         UM_LOADFILE,
    4558                          MPFROMP(pci->szFileName),
     4558                         MPFROMP(pci->pszFileName),
    45594559                         (SHORT1FROMMP(mp1) == IDM_AUTOVIEW) ?
    45604560                         MPVOID : MPFROMLONG(1L));
  • trunk/dll/makelist.c

    r606 r730  
    192192  while (pci && (INT) pci != -1 && !error) {
    193193    if (!(pci->rc.flRecordAttr & CRA_FILTERED))
    194       error = AddToList(pci->szFileName, &list, &numfiles, &numalloc);
     194      error = AddToList(pci->pszFileName, &list, &numfiles, &numalloc);
    195195    pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMP(pci),
    196196                     MPFROMSHORT(attribute));
     
    223223  while (pai && (INT) pai != -1 && !error) {
    224224    if (!(pai->rc.flRecordAttr & CRA_FILTERED))
    225       error = AddToList(pai->szFileName, &list, &numfiles, &numalloc);
     225      error = AddToList(pai->pszFileName, &list, &numfiles, &numalloc);
    226226    pai = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMP(pai),
    227227                     MPFROMSHORT(attribute));
  • trunk/dll/misc.c

    r728 r730  
    2424  18 Feb 07 GKY More drive type and drive icon support
    2525  10 Jun 07 GKY Add IsFm2Window as part of work around PM drag limit
     26  05 Jul 07 GKY Fix menu removals for WORKPLACE_PROCESS=YES
    2627
    2728***********************************************************************/
     
    651652      if (pci &&
    652653          (INT) pci != -1 &&
    653           !IsRoot(pci->szFileName) &&
     654          !IsRoot(pci->pszFileName) &&
    654655          !(pci->flags & RECFLAGS_ENV) && !(pci->flags & RECFLAGS_UNDERENV)) {
    655656        if (!pfi || pfi->offStruct == FIELDOFFSET(CNRITEM, pszFileName)) {
    656           PostMsg(hwnd, UM_FIXEDITNAME, MPFROMP(pci->szFileName), MPVOID);
     657          PostMsg(hwnd, UM_FIXEDITNAME, MPFROMP(pci->pszFileName), MPVOID);
    657658        }
    658659        else if (pfi->offStruct == FIELDOFFSET(CNRITEM, pszSubject))
     
    673674      HWND hwndMLE = WinWindowFromID(hwnd, CID_MLE);
    674675
    675       if (pci && (INT) pci != -1 && !IsRoot(pci->szFileName)) {
     676      if (pci && (INT) pci != -1 && !IsRoot(pci->pszFileName)) {
    676677        if (pfi && pfi->offStruct == FIELDOFFSET(CNRITEM, pszSubject)) {
    677678
     
    720721            eaop.fpFEA2List = pfealist;
    721722            eaop.oError = 0L;
    722             rc = DosSetPathInfo(pci->szFileName,
     723            rc = DosSetPathInfo(pci->pszFileName,
    723724                                FIL_QUERYEASIZE,
    724725                                (PVOID) & eaop, sizeof(EAOP2), DSPI_WRTTHRU);
     
    738739          chop_at_crnl(longname);
    739740          WinSetWindowText(hwndMLE, longname);
    740           return (MRESULT) WriteLongName(pci->szFileName, longname);
     741          return (MRESULT) WriteLongName(pci->pszFileName, longname);
    741742        }
    742743        else {
    743744          WinQueryWindowText(hwndMLE, sizeof(szData), szData);
    744745          if (strchr(szData, '?') ||
    745               strchr(szData, '*') || IsRoot(pci->szFileName))
     746              strchr(szData, '*') || IsRoot(pci->pszFileName))
    746747            return (MRESULT) FALSE;
    747748          /* If the text changed, rename the file system object. */
     
    755756                                 testname, sizeof(testname)))
    756757              return FALSE;
    757             if (DosQueryPathInfo(pci->szFileName,
     758            if (DosQueryPathInfo(pci->pszFileName,
    758759                                 FIL_QUERYFULLNAME, szData, sizeof(szData)))
    759               strcpy(szData, pci->szFileName);
     760              strcpy(szData, pci->pszFileName);
    760761            WinSetWindowText(hwndMLE, szData);
    761762            if (strcmp(szData, testname)) {
     
    775776                    free(filename);
    776777                }
    777                 if (stricmp(testname, pci->szFileName)) {
     778                if (stricmp(testname, pci->pszFileName)) {
    778779                  PostMsg(hwnd, UM_FIXEDITNAME, MPFROMLONG(-1), MPFROMP(pci));
    779                   filename = xstrdup(pci->szFileName, pszSrcFile, __LINE__);
     780                  filename = xstrdup(pci->pszFileName, pszSrcFile, __LINE__);
    780781                  if (filename) {
    781782                    if (!PostMsg(hwnd,
     
    797798      PCNRITEM pci = (PCNRITEM) ((PCNREDITDATA) mp2)->pRecord;
    798799
    799       if (pci && (INT) pci != -1 && !IsRoot(pci->szFileName)) {
     800      if (pci && (INT) pci != -1 && !IsRoot(pci->pszFileName)) {
    800801        WinSendMsg(hwnd,
    801802                   CM_INVALIDATERECORD,
  • trunk/dll/objcnr.c

    r689 r730  
    6767  RECORDINSERT ri;
    6868  PCNRITEM pciP;
     69  CHAR *f = 0;
    6970
    7071  ffb = xmalloc(sizeof(FILEFINDBUF3), pszSrcFile, __LINE__);
     
    9899      return;
    99100    }
    100     strcpy(pciP->szFileName, filename);
     101    pciP->pszFileName = xstrdup(filename, pszSrcFile, __LINE__);
    101102    pciP->pszDispAttr = pciP->szDispAttr;
    102     pciP->pszSubject = pciP->szSubject;
    103     pciP->pszLongname = pciP->szLongname;
     103    //pciP->pszSubject = pciP->szSubject;
     104    //pciP->pszLongname = pciP->szLongname;
    104105    pciP->pszDispAttr = pciP->szDispAttr;
    105     *pciP->szDispAttr = *pciP->szLongname = *pciP->szSubject = 0;
     106    *pciP->szDispAttr = 0;
     107    pciP->pszLongname = xstrdup(f, pszSrcFile, __LINE__);
     108    pciP->pszSubject = xstrdup(f, pszSrcFile, __LINE__);
    106109    if (strlen(filename) < 4)
    107       pciP->pszFileName = pciP->szFileName;
     110      pciP->pszFileName = pciP->pszFileName;
    108111    else {
    109       p = strrchr(pciP->szFileName, '\\');
     112      p = strrchr(pciP->pszFileName, '\\');
    110113      if (!p)
    111         pciP->pszFileName = pciP->szFileName;
     114        pciP->pszFileName = pciP->pszFileName;
    112115      else if (*(p + 1))
    113116        p++;
     
    116119    pciP->rc.pszIcon = pciP->pszFileName;
    117120    if (fForceUpper)
    118       strupr(pciP->szFileName);
     121      strupr(pciP->pszFileName);
    119122    else if (fForceLower)
    120       strlwr(pciP->szFileName);
     123      strlwr(pciP->pszFileName);
    121124    pciP->rc.flRecordAttr |= CRA_RECORDREADONLY;
    122125  }
     
    133136    HPOINTER hptr;
    134137
    135     hptr = WinLoadFileIcon(pciP->szFileName, FALSE);
     138    hptr = WinLoadFileIcon(pciP->pszFileName, FALSE);
    136139    if (hptr)
    137140      pciP->rc.hptrIcon = hptr;
     
    399402                                           MPFROMSHORT(CRA_CURSORED));
    400403        if (pci && (INT) pci != -1)
    401           strcpy(data->dirname, pci->szFileName);
     404          strcpy(data->dirname, pci->pszFileName);
    402405        WinDismissDlg(hwnd, 1);
    403406      }
  • trunk/dll/saveclip.c

    r574 r730  
    447447                    switch (*p) {
    448448                    case 's':
    449                       fputs(pci->szSubject, fp);
     449                      fputs(pci->pszSubject, fp);
    450450                      break;
    451451                    case 'S':
    452                       fprintf(fp, "%-40s", pci->szSubject);
     452                      fprintf(fp, "%-40s", pci->pszSubject);
    453453                      break;
    454454                    case 'Z':
     
    478478                      break;
    479479                    case 'l':
    480                       fputs(pci->szLongname, fp);
     480                      fputs(pci->pszLongname, fp);
    481481                      break;
    482482                    case 'L':
    483                       fprintf(fp, "%-40s", pci->szLongname);
     483                      fprintf(fp, "%-40s", pci->pszLongname);
    484484                      break;
    485485                    case 'F':
    486486                    case 'f':
    487                       if (IsRoot(pci->szFileName))
    488                         pp = pci->szFileName;
     487                      if (IsRoot(pci->pszFileName))
     488                        pp = pci->pszFileName;
    489489                      else {
    490                         pp = strrchr(pci->szFileName, '\\');
     490                        pp = strrchr(pci->pszFileName, '\\');
    491491                        if (pp)
    492492                          pp++;
    493493                        else
    494                           pp = pci->szFileName;
     494                          pp = pci->pszFileName;
    495495                      }
    496496                      if (*p == 'F')
     
    500500                      break;
    501501                    case 'p':
    502                       fputs(pci->szFileName, fp);
     502                      fputs(pci->pszFileName, fp);
    503503                      break;
    504504                    case 'P':
    505505                      temp = 0;
    506                       if (!IsRoot(pci->szFileName)) {
    507                         pp = strrchr(pci->szFileName, '\\');
     506                      if (!IsRoot(pci->pszFileName)) {
     507                        pp = strrchr(pci->pszFileName, '\\');
    508508                        if (pp) {
    509509                          temp = *pp;
     
    511511                        }
    512512                      }
    513                       fputs(pci->szFileName, fp);
     513                      fputs(pci->pszFileName, fp);
    514514                      if (temp)
    515515                        *pp = temp;
    516516                      break;
    517517                    case '$':
    518                       fputc(*pci->szFileName, fp);
     518                      fputc(*pci->pszFileName, fp);
    519519                      break;
    520520                    case '%':
  • trunk/dll/select.c

    r690 r730  
    7070        break;
    7171      if (list)
    72         AddToList(pci->szFileName, list, &numfiles, &numalloc);
     72        AddToList(pci->pszFileName, list, &numfiles, &numalloc);
    7373      pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
    7474                                  MPFROMP(pci), MPFROMSHORT(CRA_SELECTED));
     
    188188      if (maskstr && *maskstr && markit) {
    189189        markit = FALSE;
    190         file = strrchr(pci->szFileName, '\\');
     190        file = strrchr(pci->pszFileName, '\\');
    191191        if (!file)
    192           file = strrchr(pci->szFileName, ':');
     192          file = strrchr(pci->pszFileName, ':');
    193193        if (file)
    194194          file++;
    195195        else
    196           file = pci->szFileName;
     196          file = pci->pszFileName;
    197197        for (x = 0; Mask.pszMasks[x]; x++) {
    198198          if (*Mask.pszMasks[x]) {
     
    200200              if (wildcard((strchr(Mask.pszMasks[x], '\\') ||
    201201                            strchr(Mask.pszMasks[x], ':')) ?
    202                              pci->szFileName :
     202                             pci->pszFileName :
    203203                             file,
    204204                           Mask.pszMasks[x],
     
    210210              if (wildcard((strchr(Mask.pszMasks[x], '\\') ||
    211211                            strchr(Mask.pszMasks[x], ':')) ?
    212                               pci->szFileName :
     212                              pci->pszFileName :
    213213                              file,
    214214                            Mask.pszMasks[x] + 1,
     
    233233        FILE *inputFile;
    234234
    235         if ((inputFile = _fsopen(pci->szFileName, "rb", SH_DENYNO)) != NULL) {
     235        if ((inputFile = _fsopen(pci->pszFileName, "rb", SH_DENYNO)) != NULL) {
    236236          pos = ftell(inputFile);
    237237          while (!feof(inputFile)) {
     
    294294      if (maskstr && *maskstr && unmarkit) {
    295295        unmarkit = FALSE;
    296         file = strrchr(pci->szFileName, '\\');
     296        file = strrchr(pci->pszFileName, '\\');
    297297        if (!file)
    298           file = strrchr(pci->szFileName, ':');
     298          file = strrchr(pci->pszFileName, ':');
    299299        if (file)
    300300          file++;
    301301        else
    302           file = pci->szFileName;
     302          file = pci->pszFileName;
    303303        for (x = 0; Mask.pszMasks[x]; x++) {
    304304          if (*Mask.pszMasks[x]) {
     
    306306              if (wildcard((strchr(Mask.pszMasks[x], '\\') ||
    307307                            strchr(Mask.pszMasks[x], ':')) ?
    308                            pci->szFileName : file, Mask.pszMasks[x], FALSE))
     308                           pci->pszFileName : file, Mask.pszMasks[x], FALSE))
    309309                unmarkit = TRUE;
    310310            }
     
    312312              if (wildcard((strchr(Mask.pszMasks[x], '\\') ||
    313313                            strchr(Mask.pszMasks[x], ':')) ?
    314                            pci->szFileName : file, Mask.pszMasks[x] + 1,
     314                           pci->pszFileName : file, Mask.pszMasks[x] + 1,
    315315                           FALSE)) {
    316316                unmarkit = FALSE;
     
    333333        FILE *inputFile;
    334334
    335         if ((inputFile = _fsopen(pci->szFileName, "rb", SH_DENYNO)) != NULL) {
     335        if ((inputFile = _fsopen(pci->pszFileName, "rb", SH_DENYNO)) != NULL) {
    336336          pos = ftell(inputFile);
    337337          while (!feof(inputFile)) {
     
    674674  if (reset) {
    675675    for (x = 0; x < numS; x++) {
    676       if (!*pciSa[x]->szFileName || !*pciDa[x]->szFileName)
     676      if (!*pciSa[x]->pszFileName || !*pciDa[x]->pszFileName)
    677677        continue;
    678678      pciSa[x]->flags |= CNRITEM_EXISTS;
     
    730730    for (x = 0; x < numS; x++) {
    731731      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED)) {
    732         if (*pciSa[x]->szFileName &&
     732        if (*pciSa[x]->pszFileName &&
    733733            (pciSa[x]->flags & CNRITEM_EXISTS) &&
    734734            !(pciSa[x]->flags & CNRITEM_SMALLER) &&
     
    754754    for (x = 0; x < numS; x++) {
    755755      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    756           *pciSa[x]->szFileName &&
     756          *pciSa[x]->pszFileName &&
    757757          (pciSa[x]->flags & CNRITEM_EXISTS) &&
    758758          !(pciSa[x]->flags & CNRITEM_SMALLER) &&
     
    776776    for (x = 0; x < numS; x++) {
    777777      if (~pciSa[x]->rc.flRecordAttr & CRA_FILTERED &&
    778           *pciSa[x]->szFileName &&
    779           *pciDa[x]->szFileName &&
     778          *pciSa[x]->pszFileName &&
     779          *pciDa[x]->pszFileName &&
    780780          pciSa[x]->flags & CNRITEM_EXISTS &&
    781781          pciDa[x]->flags & CNRITEM_EXISTS) {
     
    790790        HAB hab = WinQueryAnchorBlock(hwndCnrS);
    791791
    792         fp1 = _fsopen(pciSa[x]->szFileName, "rb", SH_DENYNO);
     792        fp1 = _fsopen(pciSa[x]->pszFileName, "rb", SH_DENYNO);
    793793        if (!fp1) {
    794794          errLineNo = __LINE__;
     
    796796        }
    797797        else {
    798           fp2 = _fsopen(pciDa[x]->szFileName, "rb", SH_DENYNO);
     798          fp2 = _fsopen(pciDa[x]->pszFileName, "rb", SH_DENYNO);
    799799          if (!fp2) {
    800800            errLineNo = __LINE__;
     
    857857    for (x = 0; x < numS; x++) {
    858858      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    859           *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_EXISTS)) {
     859          *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_EXISTS)) {
    860860        if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
    861861          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     
    875875    for (x = 0; x < numS; x++) {
    876876      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    877           *pciSa[x]->szFileName && !(pciSa[x]->flags & CNRITEM_EXISTS)) {
     877          *pciSa[x]->pszFileName && !(pciSa[x]->flags & CNRITEM_EXISTS)) {
    878878        if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
    879879          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
    880880                     MPFROM2SHORT(TRUE, CRA_SELECTED));
    881881      }
    882       else if (*pciDa[x]->szFileName && !(pciDa[x]->flags & CNRITEM_EXISTS)) {
     882      else if (*pciDa[x]->pszFileName && !(pciDa[x]->flags & CNRITEM_EXISTS)) {
    883883        if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
    884884          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     
    895895    for (x = 0; x < numS; x++) {
    896896      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    897           *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_LARGER)) {
     897          *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_LARGER)) {
    898898        if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
    899899          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     
    901901      }
    902902      else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    903                *pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_LARGER)) {
     903               *pciDa[x]->pszFileName && (pciDa[x]->flags & CNRITEM_LARGER)) {
    904904        if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
    905905          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     
    916916    for (x = 0; x < numS; x++) {
    917917      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    918           *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_SMALLER)) {
     918          *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_SMALLER)) {
    919919        if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
    920920          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     
    922922      }
    923923      else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    924                *pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_SMALLER)) {
     924               *pciDa[x]->pszFileName && (pciDa[x]->flags & CNRITEM_SMALLER)) {
    925925        if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
    926926          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     
    937937    for (x = 0; x < numS; x++) {
    938938      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    939           *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_NEWER)) {
     939          *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_NEWER)) {
    940940        if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
    941941          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     
    943943      }
    944944      else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    945                *pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_NEWER)) {
     945               *pciDa[x]->pszFileName && (pciDa[x]->flags & CNRITEM_NEWER)) {
    946946        if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
    947947          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     
    958958    for (x = 0; x < numS; x++) {
    959959      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    960           *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_OLDER)) {
     960          *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_OLDER)) {
    961961        if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
    962962          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     
    964964      }
    965965      else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    966                *pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_OLDER)) {
     966               *pciDa[x]->pszFileName && (pciDa[x]->flags & CNRITEM_OLDER)) {
    967967        if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
    968968          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     
    979979    for (x = 0; x < numS; x++) {
    980980      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    981           *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_EXISTS)) {
     981          *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_EXISTS)) {
    982982        if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    983983          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     
    997997    for (x = 0; x < numS; x++) {
    998998      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    999           *pciSa[x]->szFileName && !(pciSa[x]->flags & CNRITEM_EXISTS)) {
     999          *pciSa[x]->pszFileName && !(pciSa[x]->flags & CNRITEM_EXISTS)) {
    10001000        if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    10011001          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
    10021002                     MPFROM2SHORT(FALSE, CRA_SELECTED));
    10031003      }
    1004       else if (*pciDa[x]->szFileName && !(pciDa[x]->flags & CNRITEM_EXISTS)) {
     1004      else if (*pciDa[x]->pszFileName && !(pciDa[x]->flags & CNRITEM_EXISTS)) {
    10051005        if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    10061006          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     
    10171017    for (x = 0; x < numS; x++) {
    10181018      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1019           *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_LARGER)) {
     1019          *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_LARGER)) {
    10201020        if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    10211021          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     
    10231023      }
    10241024      else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1025                *pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_LARGER)) {
     1025               *pciDa[x]->pszFileName && (pciDa[x]->flags & CNRITEM_LARGER)) {
    10261026        if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    10271027          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     
    10381038    for (x = 0; x < numS; x++) {
    10391039      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1040           *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_SMALLER)) {
     1040          *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_SMALLER)) {
    10411041        if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    10421042          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     
    10441044      }
    10451045      else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1046                *pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_SMALLER)) {
     1046               *pciDa[x]->pszFileName && (pciDa[x]->flags & CNRITEM_SMALLER)) {
    10471047        if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    10481048          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     
    10591059    for (x = 0; x < numS; x++) {
    10601060      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1061           *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_NEWER)) {
     1061          *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_NEWER)) {
    10621062        if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    10631063          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     
    10651065      }
    10661066      else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1067                *pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_NEWER)) {
     1067               *pciDa[x]->pszFileName && (pciDa[x]->flags & CNRITEM_NEWER)) {
    10681068        if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    10691069          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     
    10801080    for (x = 0; x < numS; x++) {
    10811081      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1082           *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_OLDER)) {
     1082          *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_OLDER)) {
    10831083        if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    10841084          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     
    10861086      }
    10871087      else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1088                *pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_OLDER)) {
     1088               *pciDa[x]->pszFileName && (pciDa[x]->flags & CNRITEM_OLDER)) {
    10891089        if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    10901090          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
  • trunk/dll/sortcnr.c

    r574 r730  
    5858  if (SortFlags & SORT_NOSORT)
    5959    return 0;
    60   if (SortFlags && pCI1->szFileName[3] && pCI2->szFileName[3]) {
     60  if (SortFlags && pCI1->pszFileName + 3 && pCI2->pszFileName + 3) {
    6161    if (SortFlags & SORT_DIRSFIRST) {
    6262      if ((pCI1->attrFile & FILE_DIRECTORY) !=
     
    7171    switch (SortFlags & (~(SORT_DIRSFIRST | SORT_DIRSLAST | SORT_REVERSE))) {
    7272    case SORT_SUBJECT:
    73       if (*pCI1->szSubject && *pCI2->szSubject)
    74         ret = stricmp(pCI1->szSubject, pCI2->szSubject);
     73      if (*pCI1->pszSubject && *pCI2->pszSubject)
     74        ret = stricmp(pCI1->pszSubject, pCI2->pszSubject);
    7575      else {
    76         ret = (*pCI2->szSubject) ? 1 : (*pCI1->szSubject) ? -1 : 0;
     76        ret = (*pCI2->pszSubject) ? 1 : (*pCI1->pszSubject) ? -1 : 0;
    7777        if (ret && (SortFlags & SORT_REVERSE))
    7878          ret = (ret > 0) ? -1 : 1;
     
    8181
    8282    case SORT_FILENAME:
    83       pch1 = strrchr(pCI1->szFileName, '\\');
    84       pch2 = strrchr(pCI2->szFileName, '\\');
     83      pch1 = strrchr(pCI1->pszFileName, '\\');
     84      pch2 = strrchr(pCI2->pszFileName, '\\');
    8585      if (!pch1)
    8686        pch1 = NullStr;
     
    9191
    9292    case SORT_FIRSTEXTENSION:
    93       pch1 = strrchr(pCI1->szFileName, '\\');
    94       pch2 = strrchr(pCI2->szFileName, '\\');
     93      pch1 = strrchr(pCI1->pszFileName, '\\');
     94      pch2 = strrchr(pCI2->pszFileName, '\\');
    9595      if (!pch1)
    96         pch1 = pCI1->szFileName;
     96        pch1 = pCI1->pszFileName;
    9797      if (!pch2)
    98         pch2 = pCI2->szFileName;
     98        pch2 = pCI2->pszFileName;
    9999      pch1 = strchr(pch1, '.');
    100100      pch2 = strchr(pch2, '.');
     
    107107
    108108    case SORT_LASTEXTENSION:
    109       pch1 = strrchr(pCI1->szFileName, '\\');
    110       pch2 = strrchr(pCI2->szFileName, '\\');
     109      pch1 = strrchr(pCI1->pszFileName, '\\');
     110      pch2 = strrchr(pCI2->pszFileName, '\\');
    111111      if (!pch1)
    112         pch1 = pCI1->szFileName;
     112        pch1 = pCI1->pszFileName;
    113113      if (!pch2)
    114         pch2 = pCI2->szFileName;
     114        pch2 = pCI2->pszFileName;
    115115      pch1 = strrchr(pch1, '.');
    116116      pch2 = strrchr(pch2, '.');
     
    189189
    190190    if (!ret)
    191       ret = (SHORT) stricmp(pCI1->szFileName, pCI2->szFileName);
     191      ret = (SHORT) stricmp(pCI1->pszFileName, pCI2->pszFileName);
    192192
    193193    if (ret && (SortFlags & SORT_REVERSE))
     
    196196    return ret;
    197197  }
    198   return (SHORT) stricmp(pCI1->szFileName, pCI2->szFileName);
     198  return (SHORT) stricmp(pCI1->pszFileName, pCI2->pszFileName);
    199199}
  • trunk/dll/systemf.c

    r632 r730  
    353353                                      MPFROMLONG(CMA_FIRST),
    354354                                      MPFROMSHORT(CRA_CURSORED));
    355           if (pci && (int) pci != -1 && *pci -> szFileName) {
    356             if (needs_quoting(pci -> szFileName) &&
    357                 !strchr(pci -> szFileName, '\"'))
     355          if (pci && (int) pci != -1 && *pci->pszFileName) {
     356            if (needs_quoting(pci->pszFileName) &&
     357                !strchr(pci->pszFileName, '\"'))
    358358            {
    359359              *pp = '\"';
     
    363363            else
    364364              spaces = FALSE;
    365             strcpy(pp, pci -> szFileName);
    366             pp += strlen(pci -> szFileName);
     365            strcpy(pp, pci->pszFileName);
     366            pp += strlen(pci->pszFileName);
    367367            if (spaces) {
    368368              *pp = '\"';
  • trunk/dll/treecnr.c

    r726 r730  
    155155                   CM_QUERYRECORDEMPHASIS,
    156156                   MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
    157   if (pci && (INT) pci != -1 && !stricmp(pci->szFileName, dirname)) {
     157  if (pci && (INT) pci != -1 && !stricmp(pci->pszFileName, dirname)) {
    158158    quickbail = TRUE;
    159159    goto MakeTop;                       /* skip lookup bullsh*t */
     
    170170      pciP = FindCnrRecord(hwndCnr, szDir, NULL, TRUE, FALSE, TRUE);
    171171      if (pciP && (INT) pciP != -1) {
    172         if (!stricmp(dirname, pciP->szFileName))
     172        if (!stricmp(dirname, pciP->pszFileName))
    173173          break;
    174174        if (!(pciP->rc.flRecordAttr & CRA_EXPANDED))
     
    199199                          MPVOID, MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
    200200        while (pciP && (INT) pciP != -1) {
    201           if (toupper(*pciP->szFileName) == toupper(*dirname))
     201          if (toupper(*pciP->pszFileName) == toupper(*dirname))
    202202            /* collapse all levels if branch is our drive */
    203203            ExpandAll(hwndCnr, FALSE, pciP);
     
    634634        sprintf(s, GetPString(IDS_NUMDRIVESTEXT), cnri.cRecords);
    635635        if (pci) {
    636           if (!(driveflags[toupper(*pci->szFileName) - 'A'] &
     636          if (!(driveflags[toupper(*pci->pszFileName) - 'A'] &
    637637                DRIVE_REMOVABLE) ||
    638               driveserial[toupper(*pci->szFileName) - 'A'] != -1) {
     638              driveserial[toupper(*pci->pszFileName) - 'A'] != -1) {
    639639            memset(&volser, 0, sizeof(volser));
    640640            DosError(FERR_DISABLEHARDERR);
    641             if (!DosQueryFSInfo(toupper(*pci->szFileName) - '@',
     641            if (!DosQueryFSInfo(toupper(*pci->pszFileName) - '@',
    642642                                FSIL_VOLSER,
    643643                                &volser,
     
    645645                dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
    646646              DosError(FERR_DISABLEHARDERR);
    647               if (!DosQueryFSInfo(toupper(*pci->szFileName) - '@',
     647              if (!DosQueryFSInfo(toupper(*pci->pszFileName) - '@',
    648648                                  FSIL_ALLOC, &fsa, sizeof(FSALLOCATE))) {
    649649                CommaFmtULL(tb, sizeof(tb),
     
    654654              else
    655655                *szFree = 0;
    656               driveserial[toupper(*pci->szFileName) - 'A'] = volser.serial;
     656              driveserial[toupper(*pci->pszFileName) - 'A'] = volser.serial;
    657657              sprintf(&s[strlen(s)],
    658658                      GetPString(IDS_TREESTATUSSTARTTEXT),
    659                       toupper(*pci->szFileName),
     659                      toupper(*pci->pszFileName),
    660660                      volser.volumelabel, volser.serial, szFree);
    661661              if (!fMoreButtons) {
     
    663663                    (dcd->mask.attrFile != ALLATTRS ||
    664664                     ((fFilesInTree ||
    665                        (driveflags[toupper(*pci->szFileName)] &
     665                       (driveflags[toupper(*pci->pszFileName)] &
    666666                        DRIVE_INCLUDEFILES)) ?
    667667                      dcd->mask.antiattr :
     
    679679            /* find root record and strip it */
    680680            pci = FindParentRecord(dcd->hwndCnr, pci);
    681             driveserial[toupper(*pci->szFileName) - 'A'] = -1;
     681            driveserial[toupper(*pci->pszFileName) - 'A'] = -1;
    682682            UnFlesh(dcd->hwndCnr, pci);
    683683          }
     
    993993      pci = (PCNRITEM) CurrentRecord(hwnd);
    994994      if (pci && (INT) pci != -1) {
    995         if (IsRoot(pci->szFileName))
     995        if (IsRoot(pci->pszFileName))
    996996          menuHwnd = CheckMenu(&TreeMenu, TREE_POPUP);
    997997        else {
     
    10671067                         MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
    10681068        if (pci && (INT) pci != -1 && fComments &&
    1069             !(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_SLOW))
    1070           WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->szFileName), MPVOID);
     1069            !(driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_SLOW))
     1070          WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->pszFileName), MPVOID);
    10711071        else
    10721072          WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
     
    10811081      if (pci) {
    10821082        if (*(ULONG *) realappname == FM3UL) {
    1083           sprintf(str, "%s %s", GetPString(IDS_DTTEXT), pci->szFileName);
     1083          sprintf(str, "%s %s", GetPString(IDS_DTTEXT), pci->pszFileName);
    10841084          WinSetWindowText(dcd->hwndFrame, str);
    10851085          WinSetWindowText(WinWindowFromID(dcd->hwndFrame, FID_TITLEBAR),
     
    10881088        else
    10891089          WinSetWindowText(WinWindowFromID(dcd->hwndFrame,
    1090                                            MAIN_STATUS), pci->szFileName);
     1090                                           MAIN_STATUS), pci->pszFileName);
    10911091        if (fMoreButtons && hwndName) {
    1092           WinSetWindowText(hwndName, pci->szFileName);
     1092          WinSetWindowText(hwndName, pci->pszFileName);
    10931093          sprintf(str,
    10941094                  "%04u/%02u/%02u %02u:%02u:%02u",
     
    11121112
    11131113      if (pci)
    1114         NotifyError(pci->szFileName, (ULONG) mp2);
     1114        NotifyError(pci->pszFileName, (ULONG) mp2);
    11151115    }
    11161116    return 0;
     
    13001300              }
    13011301              if (uso != DO_LINK &&
    1302                   !(driveflags[toupper(*pci->szFileName) - 'A'] &
     1302                  !(driveflags[toupper(*pci->pszFileName) - 'A'] &
    13031303                    DRIVE_NOTWRITEABLE)) {
    13041304
     
    13061306
    13071307                if (!fQuickArcFind &&
    1308                     !(driveflags[toupper(*pci->szFileName) - 'A'] &
     1308                    !(driveflags[toupper(*pci->pszFileName) - 'A'] &
    13091309                      DRIVE_SLOW))
    1310                   info = find_type(pci->szFileName, NULL);
     1310                  info = find_type(pci->pszFileName, NULL);
    13111311                else
    1312                   info = quick_find_type(pci->szFileName, NULL);
     1312                  info = quick_find_type(pci->pszFileName, NULL);
    13131313                if (!info || ((uso == DO_MOVE && !info->move) ||
    13141314                              (uso == DO_COPY && !info->create))) {
     
    13271327            if (!pci || (INT) pci == -1)
    13281328              return MRFROM2SHORT(DOR_DROP, DO_MOVE);
    1329             if (driveflags[toupper(*pci->szFileName) - 'A'] &
     1329            if (driveflags[toupper(*pci->pszFileName) - 'A'] &
    13301330                DRIVE_NOTWRITEABLE)
    13311331              return MRFROM2SHORT(DOR_DROP, DO_LINK);
    1332             if (toupper(*pci->szFileName) < 'C')
     1332            if (toupper(*pci->pszFileName) < 'C')
    13331333              return MRFROM2SHORT(DOR_DROP, DO_COPY);
    13341334            return MRFROM2SHORT(DOR_DROP,       /* Return okay to drop */
     
    13591359            }
    13601360            if (hwndStatus2) {
    1361               WinSetWindowText(hwndStatus2, (IsRoot(pci->szFileName)) ?
     1361              WinSetWindowText(hwndStatus2, (IsRoot(pci->pszFileName)) ?
    13621362                               GetPString(IDS_DRAGROOTTEXT) :
    13631363                               (pci->attrFile & FILE_DIRECTORY) ?
     
    15231523                if (fFollowTree &&
    15241524                    !(driveflags
    1525                       [toupper(*((PCNRITEM) pre->pRecord)->szFileName) -
     1525                      [toupper(*((PCNRITEM) pre->pRecord)->pszFileName) -
    15261526                       'A'] & DRIVE_INVALID)) {
    15271527                  if (!LastDir && !ParentIsDesktop(hwnd, dcd->hwndParent))
     
    15471547                  WinSetWindowText(WinWindowFromID(dcd->hwndFrame,
    15481548                                                   MAIN_STATUS),
    1549                                    ((PCNRITEM) (pre->pRecord))->szFileName);
     1549                                   ((PCNRITEM) (pre->pRecord))->pszFileName);
    15501550              }
    15511551            }
     
    15701570            if (!(pci->attrFile & FILE_DIRECTORY))
    15711571              dcd->hwndLastMenu = CheckMenu(&FileMenu, FILE_POPUP);
    1572             else if (!IsRoot(pci->szFileName))
     1572            else if (!IsRoot(pci->pszFileName))
    15731573              dcd->hwndLastMenu = CheckMenu(&DirMenu, DIR_POPUP);
    15741574            else
     
    16201620
    16211621          if (pci && (INT) pci != -1 && !(pci->flags & RECFLAGS_ENV)) {
    1622             if (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE) {
     1622            if (driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_REMOVABLE) {
    16231623
    16241624              struct
     
    16321632              memset(&volser, 0, sizeof(volser));
    16331633              DosError(FERR_DISABLEHARDERR);
    1634               if (!DosQueryFSInfo(toupper(*pci->szFileName) - '@',
     1634              if (!DosQueryFSInfo(toupper(*pci->pszFileName) - '@',
    16351635                                  FSIL_VOLSER, &volser,
    16361636                                  (ULONG) sizeof(volser))) {
    16371637                if (SHORT2FROMMP(mp1) == CN_COLLAPSETREE &&
    16381638                    !volser.serial ||
    1639                     driveserial[toupper(*pci->szFileName) - 'A'] !=
     1639                    driveserial[toupper(*pci->pszFileName) - 'A'] !=
    16401640                    volser.serial)
    16411641                  UnFlesh(hwnd, pci);
    16421642                if (SHORT2FROMMP(mp1) != CN_COLLAPSETREE ||
    16431643                    (!volser.serial ||
    1644                      driveserial[toupper(*pci->szFileName) - 'A'] !=
     1644                     driveserial[toupper(*pci->pszFileName) - 'A'] !=
    16451645                     volser.serial)) {
    16461646                  if (Flesh(hwnd, pci) &&
     
    16491649                    PostMsg(hwnd, UM_TOPDIR, MPFROMP(pci), MPVOID);
    16501650                }
    1651                 driveserial[toupper(*pci->szFileName) - 'A'] = volser.serial;
     1651                driveserial[toupper(*pci->pszFileName) - 'A'] = volser.serial;
    16521652              }
    16531653              else {
    1654                 driveserial[toupper(*pci->szFileName) - 'A'] = -1;
     1654                driveserial[toupper(*pci->pszFileName) - 'A'] = -1;
    16551655                UnFlesh(hwnd, pci);
    16561656                PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     
    17211721          (INT) pci != -1 &&
    17221722          !(pci->rc.flRecordAttr & CRA_INUSE) &&
    1723           !(pci->flags & RECFLAGS_ENV) && IsFullName(pci->szFileName)) {
    1724         if (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_INVALID) {
     1723          !(pci->flags & RECFLAGS_ENV) && IsFullName(pci->pszFileName)) {
     1724        if (driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_INVALID) {
    17251725          DosBeep(50, 100);
    17261726          if (hwndStatus)
     
    17301730        DosError(FERR_DISABLEHARDERR);
    17311731        if (!DosQCurDisk(&ulDriveNum, &ulDriveMap)) {
    1732           if (!(ulDriveMap & 1L << (toupper(*pci->szFileName) - 'A'))) {
     1732          if (!(ulDriveMap & 1L << (toupper(*pci->pszFileName) - 'A'))) {
    17331733            pciL = pciP = pci;
    17341734            for (;;) {
     
    17511751          }
    17521752        }
    1753         if (driveflags[toupper(*pci->szFileName) - 'A'] &
     1753        if (driveflags[toupper(*pci->pszFileName) - 'A'] &
    17541754            (DRIVE_REMOVABLE | DRIVE_NOPRESCAN)) {
    17551755
     
    17751775            }
    17761776          }
    1777           if ((driveflags[toupper(*pci->szFileName) - 'A'] &
     1777          if ((driveflags[toupper(*pci->pszFileName) - 'A'] &
    17781778               DRIVE_NOPRESCAN) ||
    1779               (toupper(*pci->szFileName) > 'B' &&
    1780                !(driveflags[toupper(*pci->szFileName) - 'A'] &
     1779              (toupper(*pci->pszFileName) > 'B' &&
     1780               !(driveflags[toupper(*pci->pszFileName) - 'A'] &
    17811781                 DRIVE_CDROM))) {
    17821782
    1783             INT removable, x = (INT) (toupper(*pci->szFileName) - 'A');
     1783            INT removable, x = (INT) (toupper(*pci->pszFileName) - 'A');
    17841784            ULONG drvtype;
    17851785            CHAR FileSystem[CCHMAXPATH];
    17861786
    17871787            DosError(FERR_DISABLEHARDERR);
    1788             removable = CheckDrive(toupper(*pciP->szFileName),
     1788            removable = CheckDrive(toupper(*pciP->pszFileName),
    17891789                                   FileSystem, &drvtype);
    17901790            if (removable != -1) {
     
    18371837          memset(&volser, 0, sizeof(volser));
    18381838          DosError(FERR_DISABLEHARDERR);
    1839           status = DosQueryFSInfo(toupper(*pci->szFileName) - '@',
     1839          status = DosQueryFSInfo(toupper(*pci->pszFileName) - '@',
    18401840                                  FSIL_VOLSER, &volser,
    18411841                                  (ULONG) sizeof(volser));
    18421842          if (!status) {
    18431843            if (!volser.serial ||
    1844                 driveserial[toupper(*pci->szFileName) - 'A'] !=
     1844                driveserial[toupper(*pci->pszFileName) - 'A'] !=
    18451845                volser.serial) {
    18461846              UnFlesh(hwnd, pciP);
    18471847              Flesh(hwnd, pciP);
    1848               driveserial[toupper(*pci->szFileName) - 'A'] = volser.serial;
     1848              driveserial[toupper(*pci->pszFileName) - 'A'] = volser.serial;
    18491849            }
    18501850            pciL = WinSendMsg(hwnd,
     
    18561856          }
    18571857          else {
    1858             driveserial[toupper(*pci->szFileName) - 'A'] = -1;
     1858            driveserial[toupper(*pci->pszFileName) - 'A'] = -1;
    18591859            UnFlesh(hwnd, pci);
    18601860            PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     
    18641864        }
    18651865        status = 0;
    1866         IsOk = (IsRoot(pci->szFileName) &&
    1867                 IsValidDrive(toupper(*pci->szFileName)));
     1866        IsOk = (IsRoot(pci->pszFileName) &&
     1867                IsValidDrive(toupper(*pci->pszFileName)));
    18681868        if (!IsOk) {
    18691869          DosError(FERR_DISABLEHARDERR);
    1870           status = DosFindFirst(pci->szFileName, &hDir,
     1870          status = DosFindFirst(pci->pszFileName, &hDir,
    18711871                                FILE_NORMAL | FILE_DIRECTORY |
    18721872                                FILE_ARCHIVED | FILE_READONLY |
     
    18851885            }
    18861886            if ((shiftstate & (KC_CTRL | KC_SHIFT)) == (KC_CTRL | KC_SHIFT)) {
    1887               OpenObject(pci->szFileName, Settings, dcd->hwndFrame);
     1887              OpenObject(pci->pszFileName, Settings, dcd->hwndFrame);
    18881888              return 0;
    18891889            }
    18901890            if (!(shiftstate & (KC_CTRL | KC_SHIFT))) {
    18911891              if (!ParentIsDesktop(hwnd, dcd->hwndParent)) {
    1892                 if (FindDirCnrByName(pci->szFileName, TRUE))
     1892                if (FindDirCnrByName(pci->pszFileName, TRUE))
    18931893                  return 0;
    18941894              }
     
    19071907                                  (PVOID) & flWindowAttr, &size);
    19081908              if (flWindowAttr & CV_DETAIL) {
    1909                 if (IsRoot(pci->szFileName))
     1909                if (IsRoot(pci->pszFileName))
    19101910                  strcpy(s, "TREE");
    19111911                else
    19121912                  strcpy(s, "DETAILS");
    19131913              }
    1914               OpenObject(pci->szFileName, s, dcd->hwndFrame);
     1914              OpenObject(pci->pszFileName, s, dcd->hwndFrame);
    19151915              return 0;
    19161916            }
     
    19201920            if (LastDir && !fDCOpens && !(shiftstate & KC_SHIFT)) {
    19211921              WinSendMsg(LastDir,
    1922                          UM_SETDIR, MPFROMP(pci->szFileName), MPVOID);
     1922                         UM_SETDIR, MPFROMP(pci->pszFileName), MPVOID);
    19231923              WinSetWindowPos(WinQueryWindow(WinQueryWindow(LastDir,
    19241924                                                            QW_PARENT),
     
    19291929              OpenDirCnr(hwnd,
    19301930                         dcd->hwndParent,
    1931                          dcd->hwndFrame, FALSE, pci->szFileName);
     1931                         dcd->hwndFrame, FALSE, pci->pszFileName);
    19321932          }
    19331933          else {
    1934             if (!(driveflags[toupper(*pci->szFileName) - 'A'] &
     1934            if (!(driveflags[toupper(*pci->pszFileName) - 'A'] &
    19351935                  DRIVE_INCLUDEFILES))
    19361936              WinSendMsg(hwnd,
     
    19451945              DefaultViewKeys(hwnd,
    19461946                              dcd->hwndFrame,
    1947                               dcd->hwndParent, &swp, pci->szFileName);
     1947                              dcd->hwndParent, &swp, pci->pszFileName);
    19481948            }
    19491949          }
    19501950        }
    19511951        else {
    1952           if (!IsRoot(pci->szFileName)) {
    1953             NotifyError(pci->szFileName, status);
     1952          if (!IsRoot(pci->pszFileName)) {
     1953            NotifyError(pci->pszFileName, status);
    19541954            WinSendMsg(hwnd,
    19551955                       CM_REMOVERECORD,
     
    20262026            CHAR szDrv[CCHMAXPATH];
    20272027
    2028             strcpy(szDrv, pci->szFileName);
    2029             chDrvU = *pci->szFileName;
     2028            strcpy(szDrv, pci->pszFileName);
     2029            chDrvU = *pci->pszFileName;
    20302030            chDrvU = toupper(chDrvU);
    20312031            MakeValidDir(szDrv);
     
    22322232
    22332233          pci = (PCNRITEM) CurrentRecord(hwnd);
    2234           if (pci && (INT) pci != -1 && isalpha(*pci->szFileName)) {
    2235             *d = toupper(*pci->szFileName);
     2234          if (pci && (INT) pci != -1 && isalpha(*pci->pszFileName)) {
     2235            *d = toupper(*pci->pszFileName);
    22362236            p = GetCmdSpec(FALSE);
    22372237            memset(&pgd, 0, sizeof(pgd));
     
    22982298          pci = (PCNRITEM) CurrentRecord(hwnd);
    22992299          if (pci && (INT) pci != -1) {
    2300             strcpy(dir, pci->szFileName);
     2300            strcpy(dir, pci->pszFileName);
    23012301            MakeValidDir(dir);
    23022302          }
     
    23302330          if (pci && (INT) pci != -1)
    23312331            dcd->mask.fFilesIncluded =
    2332               ((driveflags[toupper(*pci->szFileName) - 'A'] &
     2332              ((driveflags[toupper(*pci->pszFileName) - 'A'] &
    23332333                DRIVE_INCLUDEFILES) != 0);
    23342334          else
     
    23702370          pci = (PCNRITEM) CurrentRecord(hwnd);
    23712371          if (pci && (INT) pci != -1) {
    2372             strcpy(newpath, pci->szFileName);
     2372            strcpy(newpath, pci->pszFileName);
    23732373            MakeValidDir(newpath);
    23742374          }
     
    25562556          PCNRITEM pci = (PCNRITEM)CurrentRecord(hwnd);
    25572557          if (pci && (INT)pci != -1) {
    2558             UINT driveflag = driveflags[toupper(*pci->szFileName) - 'A'];
     2558            UINT driveflag = driveflags[toupper(*pci->pszFileName) - 'A'];
    25592559            if (pci->attrFile & FILE_DIRECTORY) {
    25602560              if (pci->flags & RECFLAGS_UNDERENV)
     
    25652565                  (~driveflag & DRIVE_NOPRESCAN && pci->rc.hptrIcon == hptrDunno))
    25662566              {
    2567                 driveflags[toupper(*pci->szFileName) - 'A'] &=
     2567                driveflags[toupper(*pci->pszFileName) - 'A'] &=
    25682568                  (DRIVE_IGNORE | DRIVE_NOPRESCAN | DRIVE_NOLOADICONS |
    25692569                   DRIVE_NOLOADSUBJS | DRIVE_NOLOADLONGS | DRIVE_NOSTATS);
    2570                 DriveFlagsOne(toupper(*pci->szFileName) - 'A');
    2571                 driveflag = driveflags[toupper(*pci->szFileName) - 'A'];
     2570                DriveFlagsOne(toupper(*pci->pszFileName) - 'A');
     2571                driveflag = driveflags[toupper(*pci->pszFileName) - 'A'];
    25722572                if (driveflag & DRIVE_INVALID)
    25732573                  pci->rc.hptrIcon = hptrDunno;
     
    26532653          pci = (PCNRITEM) CurrentRecord(hwnd);
    26542654          if (pci && (INT) pci != -1)
    2655             CommonDriveCmd(hwnd, pci->szFileName, SHORT1FROMMP(mp1));
     2655            CommonDriveCmd(hwnd, pci->pszFileName, SHORT1FROMMP(mp1));
    26562656        }
    26572657        break;
  • trunk/dll/update.c

    r557 r730  
    4040HPOINTER SelectDriveIcon(PCNRITEM pci)
    4141{
    42     UINT driveflag = driveflags[toupper(*pci->szFileName) - 'A'];
    43     *pci->szFileName = toupper(*pci->szFileName);
    44               if (isalpha(*pci->szFileName) &&
    45                   toupper(*pci->szFileName) > 'B') {
     42    UINT driveflag = driveflags[toupper(*pci->pszFileName) - 'A'];
     43    *pci->pszFileName = toupper(*pci->pszFileName);
     44              if (isalpha(*pci->pszFileName) &&
     45                  toupper(*pci->pszFileName) > 'B') {
    4646                if (driveflag & DRIVE_CDROM)
    4747                  pci->rc.hptrIcon = hptrCDROM;
     
    127127      found = TRUE;
    128128#endif
    129       if ((!fForceUpper && !fForceLower && strcmp(pci->szFileName, filename)) ||
     129      if ((!fForceUpper && !fForceLower && strcmp(pci->pszFileName, filename)) ||
    130130          pci->cbFile != ffb.cbFile || pci->attrFile != ffb.attrFile ||
    131131          pci->easize != CBLIST_TO_EASIZE(ffb.cbList) || pci->date.day !=
     
    144144        ffb.cchName = 0;
    145145        FillInRecordFromFFB(hwndCnr, pci, filename, &ffb, partial, dcd);
    146         if (strlen(pci->szFileName) < 4)
     146        if (strlen(pci->pszFileName) < 4)
    147147        SelectDriveIcon(pci);
    148148        oldemphasis = pci->rc.flRecordAttr & (CRA_SELECTED | CRA_CURSORED);
     
    180180                                              pci,
    181181                                              filename, &ffb, partial, dcd);
    182           if (strlen(pci->szFileName) < 4)
     182          if (strlen(pci->pszFileName) < 4)
    183183          SelectDriveIcon(pci);
    184184          memset(&ri, 0, sizeof(RECORDINSERT));
     
    226226                FillInRecordFromFFB(hwndCnr,
    227227                                    pci, filename, &ffb, partial, dcd);
    228                 if (strlen(pci->szFileName) < 4)
     228                if (strlen(pci->pszFileName) < 4)
    229229                SelectDriveIcon(pci);
    230230                memset(&ri, 0, sizeof(RECORDINSERT));
     
    273273                                              pci,
    274274                                              filename, &ffb, partial, dcd);
    275           if (strlen(pci->szFileName) < 4)
     275          if (strlen(pci->pszFileName) < 4)
    276276          SelectDriveIcon(pci);
    277277          memset(&ri, 0, sizeof(RECORDINSERT));
     
    300300                                FALSE,
    301301                                TRUE)) !=
    302            NULL && (INT) pci != -1 && strlen(pci->szFileName) > 3) {
     302           NULL && (INT) pci != -1 && strlen(pci->pszFileName) > 3) {
    303303    /* file doesn't exist; delete record */
    304304#ifdef DEBUG
     
    410410          /* update record? */
    411411          if ((!fForceUpper && !fForceLower &&
    412                strcmp(pci->szFileName, filename[x])) ||
     412               strcmp(pci->pszFileName, filename[x])) ||
    413413              pci->cbFile != ffb.cbFile || pci->attrFile != ffb.attrFile ||
    414414              pci->easize != CBLIST_TO_EASIZE(ffb.cbList) ||
     
    431431            FillInRecordFromFFB(hwndCnr,
    432432                                pci, filename[x], &ffb, partial, dcd);
    433             if (IsRoot(pci->szFileName))
     433            if (IsRoot(pci->pszFileName))
    434434            SelectDriveIcon(pci);
    435435            WinSendMsg(hwndCnr,
     
    455455                                                  filename[x],
    456456                                                  &ffb, partial, dcd);
    457               if (strlen(pci->szFileName) < 4)
     457              if (strlen(pci->pszFileName) < 4)
    458458              SelectDriveIcon(pci);
    459459              memset(&ri, 0, sizeof(RECORDINSERT));
     
    509509                                                        filename[x],
    510510                                                        &ffb, partial, dcd);
    511                     if (strlen(pci->szFileName) < 4)
     511                    if (strlen(pci->pszFileName) < 4)
    512512                    SelectDriveIcon(pci);
    513513                    memset(&ri, 0, sizeof(RECORDINSERT));
     
    556556                                                    filename[x],
    557557                                                    &ffb, partial, dcd);
    558                 if (strlen(pci->szFileName) < 4)
     558                if (strlen(pci->pszFileName) < 4)
    559559                SelectDriveIcon(pci);
    560560                memset(&ri, 0, sizeof(RECORDINSERT));
     
    589589                                    FALSE,
    590590                                    TRUE)) != NULL &&
    591                (INT) pci != -1 && !IsRoot(pci->szFileName)) {
     591               (INT) pci != -1 && !IsRoot(pci->pszFileName)) {
    592592        /* file doesn't exist; delete record */
    593593        if (pci->rc.flRecordAttr & CRA_SELECTED)
Note: See TracChangeset for help on using the changeset viewer.