Changeset 841


Ignore:
Timestamp:
Sep 23, 2007, 6:27:51 PM (17 years ago)
Author:
Gregg Young
Message:

This implements large file support; The wrappers to allow WARP3 compatibility are not done so this will not run on Warp3or Warp 4 pre fixpack 12(?)

Location:
trunk
Files:
54 edited

Legend:

Unmodified
Added
Removed
  • TabularUnified trunk/av2.c

    r551 r841  
    11#define INCL_DOS
    22#define INCL_WIN
     3#define INCL_LONGLONG
    34
    45#include <os2.h>
     
    2627    HDIR search_handle;
    2728    ULONG num_matches;
    28     static FILEFINDBUF3 f;
     29    static FILEFINDBUF3L f;
    2930
    3031    save_dir(s);
     
    3637      strcat(s, "*");
    3738      search_handle = HDIR_CREATE;
    38       num_matches = 1L;
    39       if (!DosFindFirst(s,
     39      num_matches = 1;
     40      if (!xDosFindFirst(s,
    4041                        &search_handle,
    4142                        FILE_NORMAL | FILE_DIRECTORY |
     
    4344                        FILE_ARCHIVED,
    4445                        &f,
    45                         sizeof(FILEFINDBUF3), &num_matches, FIL_STANDARD)) {
     46                        sizeof(FILEFINDBUF3L), &num_matches, FIL_STANDARDL)) {
    4647        do {
    4748          strcpy(enddir, f.achName);
     
    5253          else
    5354            unlinkf("%s", s);
    54         } while (!DosFindNext(search_handle,
    55                               &f, sizeof(FILEFINDBUF3), &num_matches));
     55        } while (!xDosFindNext(search_handle,
     56                              &f, sizeof(FILEFINDBUF3L), &num_matches));
    5657        DosFindClose(search_handle);
    5758      }
     
    99100                      strchr(fullname, '*') || !strchr(fullname, '.'))) {
    100101
    101       static FILEFINDBUF3 ffb;
     102      static FILEFINDBUF3L ffb;
    102103      ULONG nm;
    103104      HDIR hdir;
     
    110111        enddir++;
    111112        hdir = HDIR_CREATE;
    112         nm = 1L;
    113         if (!DosFindFirst(fullname,
     113        nm = 1;
     114        if (!xDosFindFirst(fullname,
    114115                          &hdir,
    115116                          FILE_NORMAL | FILE_SYSTEM |
    116117                          FILE_READONLY | FILE_HIDDEN | FILE_ARCHIVED,
    117                           &ffb, sizeof(FILEFINDBUF3), &nm, FIL_STANDARD)) {
     118                          &ffb, sizeof(FILEFINDBUF3L), &nm, FIL_STANDARDL)) {
    118119          strcpy(enddir, ffb.achName);
    119120          DosFindClose(hdir);
     
    129130        static CHAR path[CCHMAXPATH];
    130131        CHAR *env;
    131         FILESTATUS3 fs;
     132        FILESTATUS3L fs;
    132133
    133134        env = getenv("FM3INI");
     
    137138            DosError(FERR_DISABLEHARDERR);
    138139            if (!DosQueryPathInfo(path,
    139                                   FIL_STANDARD, &fs, (ULONG) sizeof(fs))) {
     140                                  FIL_STANDARDL, &fs, (ULONG) sizeof(fs))) {
    140141              if (!(fs.attrFile & FILE_DIRECTORY)) {
    141142                env = strrchr(path, '\\');
     
    145146              DosError(FERR_DISABLEHARDERR);
    146147              if (!DosQueryPathInfo(path,
    147                                     FIL_STANDARD, &fs, (ULONG) sizeof(fs))) {
     148                                    FIL_STANDARDL, &fs, (ULONG) sizeof(fs))) {
    148149                if (fs.attrFile & FILE_DIRECTORY)
    149150                  switch_to(path);
  • TabularUnified trunk/dll/attribs.c

    r827 r841  
    1717#define INCL_DOS
    1818#define INCL_WIN
     19#define INCL_LONGLONG
    1920#include <os2.h>
    2021
     
    9091  case UM_UNDO:
    9192    {
    92       FILESTATUS3 fi;
     93      FILESTATUS3L fi;
    9394      long ro = 2, hi = 2, sy = 2, ar = 2;
    9495      BOOL allgrey;
     
    100101      li = INSTDATA(hwnd);
    101102      if (li && li->list[0] && (allgrey || mp1) &&
    102           !DosQueryPathInfo(li->list[0], FIL_STANDARD, &fi,
     103          !DosQueryPathInfo(li->list[0], FIL_STANDARDL, &fi,
    103104                            (ULONG) sizeof(fi))) {
    104105        ro = ((fi.attrFile & FILE_READONLY) != 0);
     
    279280      }
    280281      {
    281         ULONG temp = 0L;
    282         FILESTATUS3 fi;
     282        ULONG temp = 0;
     283        FILESTATUS3L fi;
    283284        SHORT x;
    284285        APIRET rc;
     
    326327        for (x = 0; li->list[x]; x++) {
    327328          DosError(FERR_DISABLEHARDERR);
    328           rc = DosQueryPathInfo(li->list[x], FIL_STANDARD, &fi,
     329          rc = DosQueryPathInfo(li->list[x], FIL_STANDARDL, &fi,
    329330                                (ULONG) sizeof(fi));
    330331          if (rc)
     
    333334            WinSendDlgItemMsg(hwnd, ATR_YEAR, SPBM_QUERYVALUE, MPFROMP(&temp),
    334335                              MPFROM2SHORT(0, SPBQ_DONOTUPDATE));
    335             fi.fdateLastWrite.year = temp - 1980L;
     336            fi.fdateLastWrite.year = temp - 1980;
    336337            WinSendDlgItemMsg(hwnd, ATR_MONTH, SPBM_QUERYVALUE,
    337338                              MPFROMP(&temp), MPFROM2SHORT(0,
     
    378379          else if (state == 1)
    379380            fi.attrFile |= FILE_ARCHIVED;
    380           xDosSetPathInfo(li->list[x], FIL_STANDARD, &fi, sizeof(fi), 0);
     381          xDosSetPathInfo(li->list[x], FIL_STANDARDL, &fi, sizeof(fi), 0);
    381382        }
    382383        WinDismissDlg(hwnd, 1);
  • TabularUnified trunk/dll/autoview.c

    r838 r841  
    2626#define INCL_WIN
    2727#define INCL_GPI
     28#define INCL_LONGLONG
    2829#include <os2.h>
    2930
     
    193194    memset(&eaop, 0, sizeof(eaop));
    194195    eaop.fpFEA2List = pfealist;
    195     pfealist->cbList = 13L + (ULONG) pfealist->list[0].cbName +
     196    pfealist->cbList = 13 + (ULONG) pfealist->list[0].cbName +
    196197      (ULONG) pfealist->list[0].cbValue;
    197198    rc = xDosSetPathInfo(filename, FIL_QUERYEASIZE,
     
    299300
    300301            HFILE handle;
    301             ULONG action, olen, ibufflen, obufflen, l;
     302            ULONG olen, ibufflen, action, obufflen, l;
    302303            CHAR *ibuff, *obuff, *p, buffer[80];
    303304            ARC_TYPE *info;
    304305
    305             if (!DosOpen((CHAR *) mp1,
    306                          &handle,
    307                          &action,
    308                          0L,
    309                          0L,
    310                          OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
    311                          OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
    312                          OPEN_FLAGS_RANDOMSEQUENTIAL | OPEN_SHARE_DENYNONE |
    313                          OPEN_ACCESS_READONLY, 0L)) {
     306            if (!DosOpenL((CHAR *) mp1,
     307                          &handle,
     308                          &action,
     309                          0,
     310                          0,
     311                          OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
     312                          OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
     313                          OPEN_FLAGS_RANDOMSEQUENTIAL | OPEN_SHARE_DENYNONE |
     314                          OPEN_ACCESS_READONLY, 0)) {
    314315              ibufflen = (AutoviewHeight < 96) ? 512 : 3072;
    315316              ibuff = xmalloc(ibufflen + 2, pszSrcFile, __LINE__);
     
    410411          else if (!IsFile(currfile)) {
    411412
    412             static FILEFINDBUF4 ffb[130];
     413            static FILEFINDBUF4L ffb[130];
    413414            CHAR fullname[CCHMAXPATH + 4];
    414415            HDIR hdir = HDIR_CREATE;
    415416            ULONG x, nm, ml, mc, bufflen;
    416417            PBYTE fb;
    417             PFILEFINDBUF4 pffbFile;
     418            PFILEFINDBUF4L pffbFile;
    418419            PSZ pszBuf;
    419420            PSZ p;
     
    426427            //        (currfile[strlen(currfile) - 1] == '\\') ? "" : "\\");
    427428            DosError(FERR_DISABLEHARDERR);
    428             nm = sizeof(ffb) / sizeof(FILEFINDBUF4);
     429            nm = sizeof(ffb) / sizeof(FILEFINDBUF4L);
    429430            if (AutoviewHeight < 96)
    430431              nm /= 2;
     
    434435                               FILE_READONLY | FILE_ARCHIVED |
    435436                               FILE_SYSTEM | FILE_HIDDEN,
    436                                &ffb, sizeof(ffb), &nm, FIL_QUERYEASIZE);
     437                               &ffb, sizeof(ffb), &nm, FIL_QUERYEASIZEL);
    437438            if (!rc && nm) {
    438439              fb = (PBYTE) & ffb;
    439440              x = ml = 0;
    440441              while (x < nm) {
    441                 pffbFile = (PFILEFINDBUF4) fb;
     442                pffbFile = (PFILEFINDBUF4L) fb;
    442443                mc = (ULONG) pffbFile->cchName +
    443444                  ((pffbFile->attrFile & FILE_DIRECTORY) != 0);
     
    456457                x = 0;
    457458                while (x < nm) {
    458                   pffbFile = (PFILEFINDBUF4) fb;
     459                  pffbFile = (PFILEFINDBUF4L) fb;
    459460                  if (!(!*pffbFile->achName ||
    460461                        (((pffbFile->attrFile & FILE_DIRECTORY) &&
  • TabularUnified trunk/dll/avl.c

    r832 r841  
    3636#define INCL_WINSTDDRAG
    3737#define INCL_DOS
     38#define INCL_LONGLONG
    3839#include <os2.h>
    3940
     
    168169    topsig = arcsighead;
    169170  DosError(FERR_DISABLEHARDERR);
    170   if (DosOpen(filespec,
    171               &handle,
    172               &action,
    173               0,
    174               0,
    175               OPEN_ACTION_FAIL_IF_NEW |
    176               OPEN_ACTION_OPEN_IF_EXISTS,
    177               OPEN_FLAGS_FAIL_ON_ERROR |
    178               OPEN_FLAGS_NOINHERIT |
    179               OPEN_FLAGS_RANDOMSEQUENTIAL |
    180               OPEN_SHARE_DENYNONE | OPEN_ACCESS_READONLY, 0))
     171  if (DosOpenL(filespec,
     172               &handle,
     173               &action,
     174               0,
     175               0,
     176               OPEN_ACTION_FAIL_IF_NEW |
     177               OPEN_ACTION_OPEN_IF_EXISTS,
     178               OPEN_FLAGS_FAIL_ON_ERROR |
     179               OPEN_FLAGS_NOINHERIT |
     180               OPEN_FLAGS_RANDOMSEQUENTIAL |
     181               OPEN_SHARE_DENYNONE | OPEN_ACCESS_READONLY, 0))
    181182    return NULL;
    182183  // Scan signatures
  • TabularUnified trunk/dll/chklist.c

    r793 r841  
    1919#define INCL_WIN
    2020#define INCL_GPI
     21#define INCL_LONGLONG
    2122#include <os2.h>
    2223
     
    430431
    431432            FILEDLG fdlg;
    432             FILESTATUS3 fs3;
     433            FILESTATUS3L fs3;
    433434            CHAR drive[3], *pdrive = drive, filename[CCHMAXPATH], *p;
    434435
     
    459460                                      filename, sizeof(filename))) {
    460461                  if (!DosQueryPathInfo(filename,
    461                                         FIL_STANDARD, &fs3, sizeof(fs3))) {
     462                                        FIL_STANDARDL, &fs3, sizeof(fs3))) {
    462463                    p = filename;
    463464                    while (*p) {
     
    469470                    PostMsg(hwnd, UM_UNDO, MPVOID, MPVOID);
    470471                  }
    471 // else saymsg(MB_ENTER,hwnd,DEBUG_STRING,"DosQueryPathInfo FIL_STANDARD failed");
     472// else saymsg(MB_ENTER,hwnd,DEBUG_STRING,"DosQueryPathInfo FIL_STANDARDL failed");
    472473                }
    473474// else saymsg(MB_ENTER,hwnd,DEBUG_STRING,"DosQueryPathInfo FIL_QUERYFULLNAME failed");
  • TabularUnified trunk/dll/collect.c

    r838 r841  
    547547      LISTINFO *li = (LISTINFO *) mp1;
    548548      INT x;
    549       FILEFINDBUF4 fb4;
     549      FILEFINDBUF4L fb4;
    550550      HDIR hdir;
    551551      ULONG nm;
     
    590590                               FILE_ARCHIVED | FILE_SYSTEM |
    591591                               FILE_HIDDEN | FILE_READONLY,
    592                                &fb4, sizeof(fb4), &nm, FIL_QUERYEASIZE)) {
     592                               &fb4, sizeof(fb4), &nm, FIL_QUERYEASIZEL)) {
    593593              DosFindClose(hdir);
    594594              priority_normal();
     
    638638    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
    639639    if (dcd && mp1) {
    640       FILESTATUS4 fs4;
     640      FILESTATUS4L fs4;
    641641      PCNRITEM pci;
    642642      RECORDINSERT ri;
     
    683683                !IsRoot(fullname) &&
    684684                !DosQueryPathInfo(fullname,
    685                                   FIL_QUERYEASIZE,
     685                                  FIL_QUERYEASIZEL,
    686686                                  &fs4,
    687687                                  sizeof(fs4)) &&
     
    25082508        if (mp2) {
    25092509          PCNRITEM pci = (PCNRITEM) ((PNOTIFYRECORDENTER) mp2)->pRecord;
    2510           FILEFINDBUF3 ffb;
     2510          FILEFINDBUF3L ffb;
    25112511          HDIR hDir = HDIR_CREATE;
    25122512          ULONG nm = 1;
     
    25222522                                   FILE_ARCHIVED | FILE_READONLY |
    25232523                                   FILE_HIDDEN | FILE_SYSTEM,
    2524                                    &ffb, sizeof(ffb), &nm, FIL_STANDARD);
     2524                                   &ffb, sizeof(ffb), &nm, FIL_STANDARDL);
    25252525            priority_bumped();
    25262526            if (!status) {
  • TabularUnified trunk/dll/common.c

    r809 r841  
    2727#define INCL_WIN
    2828#define INCL_GPI
     29#define INCL_LONGLONG
    2930#include <os2.h>
    3031
     
    272273
    273274      BYTE parm[4] = { "CD01" };
    274       ULONG dlen, plen;
     275      ULONGLONG dlen;
     276      ULONG plen;
    275277      HFILE hfile;
    276278      APIRET rc;
    277279
    278280      dv[2] = 0;
    279       rc = DosOpen(dv,
    280                    &hfile,
    281                    &dlen,
    282                    0,
    283                    0,
    284                    OPEN_ACTION_OPEN_IF_EXISTS |
    285                    OPEN_ACTION_CREATE_IF_NEW,
    286                    OPEN_FLAGS_DASD |
    287                    OPEN_FLAGS_FAIL_ON_ERROR | OPEN_SHARE_DENYNONE, NULL);
     281      rc = DosOpenL(dv,
     282                    &hfile,
     283                    &dlen,
     284                    0,
     285                    0,
     286                    OPEN_ACTION_OPEN_IF_EXISTS |
     287                    OPEN_ACTION_CREATE_IF_NEW,
     288                    OPEN_FLAGS_DASD |
     289                    OPEN_FLAGS_FAIL_ON_ERROR | OPEN_SHARE_DENYNONE, NULL);
    288290      if (rc)
    289         Dos_Error(MB_CANCEL, rc, hwnd, pszSrcFile, __LINE__, "DosOpen");
     291        Dos_Error(MB_CANCEL, rc, hwnd, pszSrcFile, __LINE__, "DosOpenL");
    290292      else {
    291293        dlen = 0;
  • TabularUnified trunk/dll/comp.c

    r838 r841  
    9494static VOID SnapShot(char *path, FILE *fp, BOOL recurse)
    9595{
    96   PFILEFINDBUF4 pffb;
     96  PFILEFINDBUF4L pffb;
    9797  char *mask, *enddir;
    9898  HDIR hdir = HDIR_CREATE;
     
    100100
    101101  // 13 Aug 07 SHL fimxe to use FileToGet
    102   pffb = xmalloc(sizeof(FILEFINDBUF4), pszSrcFile, __LINE__);
     102  pffb = xmalloc(sizeof(FILEFINDBUF4L), pszSrcFile, __LINE__);
    103103  if (pffb) {
    104104    mask = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__);
     
    117117                         FILE_ARCHIVED | FILE_READONLY | FILE_HIDDEN |
    118118                         FILE_SYSTEM,
    119                          pffb, sizeof(FILEFINDBUF4), &ulFindCnt, FIL_QUERYEASIZE)) {
     119                         pffb, sizeof(FILEFINDBUF4L), &ulFindCnt, FIL_QUERYEASIZEL)) {
    120120        do {
    121121          strcpy(enddir, pffb->achName);
     
    141141          }
    142142          ulFindCnt = 1;
    143         } while (!xDosFindNext(hdir, pffb, sizeof(FILEFINDBUF4), &ulFindCnt));
     143        } while (!xDosFindNext(hdir, pffb, sizeof(FILEFINDBUF4L), &ulFindCnt));
    144144        DosFindClose(hdir);
    145145      }
     
    190190  HMQ hmq2;
    191191  FILE *fp1, *fp2;
    192   ULONG len1, len2, offset = 0L;
     192  ULONGLONG len1, len2;
     193  ULONG offset = 0;
    193194  LONG numread1, numread2;
    194195  CHAR s[1024], ss[1024], *p1, *p2;
     
    236237          }
    237238          else {
    238             len1 = filelength(fileno(fp1));
    239             len2 = filelength(fileno(fp2));
     239            len1 = _filelengthi64(fileno(fp1));
     240            len2 = _filelengthi64(fileno(fp2));
    240241            if (len1 != len2) {
    241242              strcpy(s, GetPString(IDS_COMPDIFSIZESTEXT));
     
    738739  ULONG x;
    739740  CHAR *maskstr;
    740   PFILEFINDBUF4 pffbArray;
    741   PFILEFINDBUF4 pffbFile;
     741  PFILEFINDBUF4L pffbArray;
     742  PFILEFINDBUF4L pffbFile;
    742743  HDIR hDir;
    743744  ULONG ulFindCnt;
    744   ULONG ulBufBytes = sizeof(FILEFINDBUF4) * FilesToGet;
     745  ULONG ulBufBytes = sizeof(FILEFINDBUF4L) * FilesToGet;
    745746  APIRET rc;
    746747
     
    775776                     FILE_SYSTEM | FILE_HIDDEN |
    776777                     (recurse ? FILE_DIRECTORY : 0),
    777                      pffbArray, ulBufBytes, &ulFindCnt, FIL_QUERYEASIZE);
     778                     pffbArray, ulBufBytes, &ulFindCnt, FIL_QUERYEASIZEL);
    778779  if (!rc) {
    779780    do {
     
    805806          }
    806807        }
    807         pffbFile = (PFILEFINDBUF4)((PBYTE)pffbFile + pffbFile->oNextEntryOffset);
     808        pffbFile = (PFILEFINDBUF4L)((PBYTE)pffbFile + pffbFile->oNextEntryOffset);
    808809      } // for
    809810      DosError(FERR_DISABLEHARDERR);
     
    928929        // Use snapshot file
    929930        FILE *fp;
    930         FILEFINDBUF4 fb4;
     931        FILEFINDBUF4L fb4;
    931932        CHAR str[CCHMAXPATH * 2], *p;
    932933
  • TabularUnified trunk/dll/copyf.c

    r838 r841  
    2424#define INCL_DOSERRORS
    2525#define INCL_WIN
     26#define INCL_LONGLONG
    2627#include <os2.h>
    2728
     
    5051char *MakeTempName(char *buffer)
    5152{
    52   FILESTATUS3 fs3;
     53  FILESTATUS3L fs3;
    5354  APIRET rc;
    5455  char *p, *o;
     
    5960  for (;;) {
    6061    DosError(FERR_DISABLEHARDERR);
    61     rc = DosQueryPathInfo(buffer, FIL_STANDARD, &fs3, (ULONG) sizeof(fs3));
     62    rc = DosQueryPathInfo(buffer, FIL_STANDARDL, &fs3, (ULONG) sizeof(fs3));
    6263    if (rc == ERROR_DISK_CHANGE) {
    6364      DosError(FERR_ENABLEHARDERR);
    64       rc = DosQueryPathInfo(buffer, FIL_STANDARD, &fs3, (ULONG) sizeof(fs3));
     65      rc = DosQueryPathInfo(buffer, FIL_STANDARDL, &fs3, (ULONG) sizeof(fs3));
    6566    }
    6667    if (rc)
     
    9091{
    9192  CHAR *p, *f, *s, *o;
    92   FILESTATUS3 fs3;
     93  FILESTATUS3L fs3;
    9394  APIRET rc;
    9495
     
    153154  for (;;) {
    154155    DosError(FERR_DISABLEHARDERR);
    155     rc = DosQueryPathInfo(buffer, FIL_STANDARD, &fs3, (ULONG) sizeof(fs3));
     156    rc = DosQueryPathInfo(buffer, FIL_STANDARDL, &fs3, (ULONG) sizeof(fs3));
    156157    if (rc == ERROR_DISK_CHANGE) {
    157158      DosError(FERR_ENABLEHARDERR);
    158       rc = DosQueryPathInfo(buffer, FIL_STANDARD, &fs3, (ULONG) sizeof(fs3));
     159      rc = DosQueryPathInfo(buffer, FIL_STANDARDL, &fs3, (ULONG) sizeof(fs3));
    159160    }
    160161    if (rc)
     
    281282    memset(pfealist, 0, ealen + 1);
    282283    pfealist->cbList = ealen;
    283     pfealist->list[0].oNextEntryOffset = 0L;
     284    pfealist->list[0].oNextEntryOffset = 0;
    284285    pfealist->list[0].fEA = 0;
    285286    pfealist->list[0].cbName = 9;
     
    352353APIRET docopyallf(INT type, CHAR * oldname, CHAR * newname, ...)
    353354{
    354   FILEFINDBUF3 fb;
     355  FILEFINDBUF3L fb;
    355356  ULONG nm;
    356357  HDIR hdir;
     
    408409  CHAR olddisk, newdisk, dir[CCHMAXPATH], *p, *pp;
    409410  APIRET ret = -1, rc;
    410   FILESTATUS3 st, st2, dummy;
     411  FILESTATUS3L st, st2, dummy;
    411412  BOOL diskchange = FALSE, zaplong = FALSE;
    412413  va_list ap;
     
    422423
    423424  DosError(FERR_DISABLEHARDERR);
    424   if (DosQueryPathInfo(oldname, FIL_STANDARD, &st, sizeof(FILESTATUS3)))
     425  if (DosQueryPathInfo(oldname, FIL_STANDARDL, &st, sizeof(FILESTATUS3L)))
    425426    return (APIRET) - 2;                /* no source */
    426427
     
    585586        DosError(FERR_DISABLEHARDERR);
    586587        rc = DosQueryPathInfo(fullnewname,
    587                               FIL_STANDARD, &st2, sizeof(FILESTATUS3));
     588                              FIL_STANDARDL, &st2, sizeof(FILESTATUS3L));
    588589        if (rc == ERROR_DISK_CHANGE) {
    589590          DosError(FERR_ENABLEHARDERR);
    590591          rc = DosQueryPathInfo(fullnewname,
    591                                 FIL_STANDARD, &st2, sizeof(FILESTATUS3));
     592                                FIL_STANDARDL, &st2, sizeof(FILESTATUS3L));
    592593        }
    593594        if (!rc && st2.cbFile == st.cbFile) {   /* seems to have worked... */
     
    595596          if (diskchange) {
    596597            DosError(FERR_ENABLEHARDERR);
    597             DosQueryPathInfo(oldname, FIL_STANDARD, &dummy, sizeof(FILESTATUS3));       /* force disk change */
     598            DosQueryPathInfo(oldname, FIL_STANDARDL, &dummy, sizeof(FILESTATUS3L));     /* force disk change */
    598599          }
    599600          if (!(st2.attrFile & FILE_DIRECTORY)) /* erase file */
     
    661662{
    662663  INT ret = -1;
    663   FILESTATUS3 fsi;
     664  FILESTATUS3L fsi;
    664665
    665666  DosError(FERR_DISABLEHARDERR);
    666   if (!DosQueryPathInfo(filename, FIL_STANDARD, &fsi, sizeof(fsi))) {
     667  if (!DosQueryPathInfo(filename, FIL_STANDARDL, &fsi, sizeof(fsi))) {
    667668    fsi.attrFile = 0;
    668669    DosError(FERR_DISABLEHARDERR);
    669     if (!xDosSetPathInfo(filename, FIL_STANDARD, &fsi, sizeof(fsi), 0))
     670    if (!xDosSetPathInfo(filename, FIL_STANDARDL, &fsi, sizeof(fsi), 0))
    670671      ret = 0;
    671672  }
     
    677678  /* unlink everything from directory on down... */
    678679
    679   FILEFINDBUF3 *f;
     680  FILEFINDBUF3L *f;
    680681  HDIR search_handle;
    681682  ULONG num_matches;
     
    735736
    736737  ss = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__);
    737   f = xmalloc(sizeof(FILEFINDBUF3), pszSrcFile, __LINE__);
     738  f = xmalloc(sizeof(FILEFINDBUF3L), pszSrcFile, __LINE__);
    738739  if (!ss || !f) {
    739740    xfree(ss);
     
    744745
    745746  search_handle = HDIR_CREATE;
    746   num_matches = 1L;
     747  num_matches = 1;
    747748
    748749  DosError(FERR_DISABLEHARDERR);
    749750  if (!xDosFindFirst(str, &search_handle, FILE_NORMAL | FILE_DIRECTORY |
    750751                     FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN | FILE_ARCHIVED,
    751                      f, sizeof(FILEFINDBUF3), &num_matches, FIL_STANDARD)) {
     752                     f, sizeof(FILEFINDBUF3L), &num_matches, FIL_STANDARDL)) {
    752753
    753754    strcpy(ss, s);
     
    779780      num_matches = 1L;
    780781      DosError(FERR_DISABLEHARDERR);
    781     } while (!xDosFindNext(search_handle, f, sizeof(FILEFINDBUF3),
     782    } while (!xDosFindNext(search_handle, f, sizeof(FILEFINDBUF3L),
    782783                           &num_matches));
    783784    DosFindClose(search_handle);
     
    794795  /* wildcard delete */
    795796
    796   FILEFINDBUF3 *f;
     797  FILEFINDBUF3L *f;
    797798  HDIR search_handle;
    798799  ULONG num_matches;
     
    829830
    830831  ss = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__);
    831   f = xmalloc(sizeof(FILEFINDBUF3), pszSrcFile, __LINE__);
     832  f = xmalloc(sizeof(FILEFINDBUF3L), pszSrcFile, __LINE__);
    832833  if (!ss || !f) {
    833834    xfree(ss);
     
    842843  DosError(FERR_DISABLEHARDERR);
    843844  if (!xDosFindFirst(str, &search_handle, FILE_NORMAL, f,
    844                      sizeof(FILEFINDBUF3), &num_matches, FIL_STANDARD)) {
     845                     sizeof(FILEFINDBUF3L), &num_matches, FIL_STANDARDL)) {
    845846
    846847    strcpy(ss, s);
     
    852853      num_matches = 1;
    853854      DosError(FERR_DISABLEHARDERR);
    854     } while (!xDosFindNext(search_handle, f, sizeof(FILEFINDBUF3),
     855    } while (!xDosFindNext(search_handle, f, sizeof(FILEFINDBUF3L),
    855856                           &num_matches));
    856857    DosFindClose(search_handle);
  • TabularUnified trunk/dll/datamin.c

    r838 r841  
    742742    {
    743743      CHAR s[134], szFileQty[38], szFreeQty[38];
    744       FILEFINDBUF3 ffb;
     744      FILEFINDBUF3L ffb;
    745745      ULONG nm = 1;
    746746      ULONGLONG ullFreeQty;
     
    752752        if (!xDosFindFirst(SwapperDat, &hdir, FILE_NORMAL | FILE_HIDDEN |
    753753                           FILE_SYSTEM | FILE_ARCHIVED | FILE_READONLY,
    754                            &ffb, sizeof(ffb), &nm, FIL_STANDARD)) {
     754                           &ffb, sizeof(ffb), &nm, FIL_STANDARDL)) {
    755755          priority_bumped();
    756756          DosFindClose(hdir);
  • TabularUnified trunk/dll/dircnrs.c

    r838 r841  
    31273127
    31283128          PCNRITEM pci = (PCNRITEM) ((PNOTIFYRECORDENTER) mp2)->pRecord;
    3129           FILEFINDBUF3 ffb;
     3129          FILEFINDBUF3L ffb;
    31303130          HDIR hDir = HDIR_CREATE;
    31313131          ULONG nm = 1;
     
    31423142                                   FILE_ARCHIVED | FILE_READONLY |
    31433143                                   FILE_HIDDEN | FILE_SYSTEM,
    3144                                    &ffb, sizeof(ffb), &nm, FIL_STANDARD);
     3144                                   &ffb, sizeof(ffb), &nm, FIL_STANDARDL);
    31453145            priority_bumped();
    31463146            if (!status) {
     
    31823182                  DosExitCritSec();
    31833183                  if (!PostMsg(dcd->hwndObject,
    3184                                UM_RESCAN, MPVOID, MPFROMLONG(1L))) {
     3184                               UM_RESCAN, MPVOID, MPFROMLONG(1))) {
    31853185                    DosEnterCritSec();
    31863186                    dcd->stopflag--;
  • TabularUnified trunk/dll/dirs.c

    r793 r841  
    1717#define INCL_DOS
    1818#define INCL_DOSERRORS
     19#define INCL_LONGLONG
    1920
    2021#include <os2.h>
     
    6869
    6970  APIRET ret;
    70   FILESTATUS3 fsa;
     71  FILESTATUS3L fsa;
    7172  CHAR path[CCHMAXPATH + 1], *p;
    7273
    7374  strcpy(path, s);
    7475  while (*path) {
    75     ret = DosQueryPathInfo(path, FIL_STANDARD, &fsa,
    76                            (ULONG) sizeof(FILESTATUS3));
     76    ret = DosQueryPathInfo(path, FIL_STANDARDL, &fsa,
     77                           (ULONG) sizeof(FILESTATUS3L));
    7778    if (ret || !(fsa.attrFile & FILE_DIRECTORY)) {
    7879      p = strrchr(path, '\\');
  • TabularUnified trunk/dll/dirsize.c

    r838 r841  
    100100  ULONGLONG ull;
    101101  HDIR hdir;
    102   PFILEFINDBUF4 pffbArray;
     102  PFILEFINDBUF4L pffbArray;
    103103  APIRET rc;
    104104  RECORDINSERT ri;
     
    108108  *pullTotalBytes = 0;                  // In case we fail
    109109
    110   ulBufBytes = sizeof(FILEFINDBUF4) * FilesToGet;
     110  ulBufBytes = sizeof(FILEFINDBUF4L) * FilesToGet;
    111111  pffbArray = xmalloc(ulBufBytes, pszSrcFile, __LINE__);
    112112  if (!pffbArray)
     
    121121  hdir = HDIR_CREATE;
    122122  ulFindCnt = 1;
    123   // memset(pffbArray, 0, sizeof(FILEFINDBUF4));        // 11 Aug 07 SHL bypass memset
     123  // memset(pffbArray, 0, sizeof(FILEFINDBUF4L));       // 11 Aug 07 SHL bypass memset
    124124  DosError(FERR_DISABLEHARDERR);
    125125  // Check directory exists
     
    127127                     FILE_NORMAL | FILE_READONLY | FILE_ARCHIVED |
    128128                     FILE_SYSTEM | FILE_HIDDEN | MUST_HAVE_DIRECTORY,
    129                      pffbArray, ulBufBytes, &ulFindCnt, FIL_QUERYEASIZE);
     129                     pffbArray, ulBufBytes, &ulFindCnt, FIL_QUERYEASIZEL);
    130130
    131131  if (!rc)
     
    216216                     FILE_NORMAL | FILE_READONLY | FILE_ARCHIVED |
    217217                     FILE_SYSTEM | FILE_HIDDEN | FILE_DIRECTORY,
    218                      pffbArray, ulBufBytes, &ulFindCnt, FIL_QUERYEASIZE);
     218                     pffbArray, ulBufBytes, &ulFindCnt, FIL_QUERYEASIZEL);
    219219  if (!rc) {
    220     PFILEFINDBUF4 pffbFile;
     220    PFILEFINDBUF4L pffbFile;
    221221    ULONG x;
    222222
     
    257257        if (!pffbFile->oNextEntryOffset)
    258258          break;
    259         pffbFile = (PFILEFINDBUF4)((PBYTE)pffbFile + pffbFile->oNextEntryOffset);
     259        pffbFile = (PFILEFINDBUF4L)((PBYTE)pffbFile + pffbFile->oNextEntryOffset);
    260260
    261261#if 0 // 13 Aug 07 SHL fixme to be gone
  • TabularUnified trunk/dll/draglist.c

    r793 r841  
    2727#define INCL_WIN
    2828#define INCL_SHLERRORS
     29#define INCL_LONGLONG
    2930#include <os2.h>
    3031
     
    114115  DRAGIMAGE fakeicon;
    115116  PDRAGINFO pDInfo;
    116   FILESTATUS3 fs3;
     117  FILESTATUS3L fs3;
    117118  CHAR szDir[CCHMAXPATH], szFile[CCHMAXPATH], *p;
    118119
    119120  if (filename && *filename) {
    120121    if ((IsRoot(filename) && IsValidDrive(*filename)) ||
    121         !DosQueryPathInfo(filename, FIL_STANDARD, &fs3, sizeof(fs3))) {
     122        !DosQueryPathInfo(filename, FIL_STANDARDL, &fs3, sizeof(fs3))) {
    122123      strcpy(szDir, filename);
    123124      p = szDir;
     
    587588  CHAR szFile[CCHMAXPATH], szBuffer[CCHMAXPATH];
    588589  DRAGIMAGE *paDImgIcons = NULL, *pDImg;
    589   FILESTATUS3 fs3;
     590  FILESTATUS3L fs3;
    590591  BOOL ok;
    591592  DIRCNRDATA *dcd;
     
    598599  for (ulSelect = 0; list[ulSelect]; ulSelect++) {
    599600    if ((!IsRoot(list[ulSelect]) || !IsValidDrive(*list[ulSelect])) &&
    600         DosQueryPathInfo(list[ulSelect], FIL_STANDARD, &fs3, sizeof(fs3)))
     601        DosQueryPathInfo(list[ulSelect], FIL_STANDARDL, &fs3, sizeof(fs3)))
    601602      continue;
    602603    strcpy(szBuffer, list[ulSelect]);
  • TabularUnified trunk/dll/droplist.c

    r793 r841  
    2626#define INCL_DOS
    2727#define INCL_WIN
     28#define INCL_LONGLONG
    2829#include <os2.h>
    2930
     
    9697      }
    9798      {                                 /* be sure that file/directory is accessible */
    98         FILESTATUS3 fsa3;
     99        FILESTATUS3L fsa3;
    99100
    100101        DosError(FERR_DISABLEHARDERR);
    101102        if (DosQueryPathInfo(buffer1,
    102                              FIL_STANDARD,
     103                             FIL_STANDARDL,
    103104                             &fsa3,
    104105                             sizeof(fsa3)) ||
     
    165166    }
    166167    {                                   /* be sure that file/directory is accessible */
    167         FILESTATUS3 fsa3;
    168 
    169       rc = DosQueryPathInfo(buffer, FIL_STANDARD, &fsa3, sizeof(fsa3));
     168        FILESTATUS3L fsa3;
     169
     170      rc = DosQueryPathInfo(buffer, FIL_STANDARDL, &fsa3, sizeof(fsa3));
    170171      if (!rc)
    171172        ret = TRUE;
     
    287288  CHAR **files = NULL;
    288289  UINT numfiles = 0, numalloc = 0;
    289   ULONG curitem, numitems, *cbFile = NULL, *ulitemID = NULL;
     290  ULONG curitem, numitems;
     291  PULONGLONG pcbFile = NULL;
     292  PULONG pulitemID = NULL;
    290293  LISTINFO *li = NULL;
    291294  ARC_TYPE *arcinfo = NULL;
     
    416419
    417420        CHAR **test;
    418         ULONG *ltest;
     421        PULONG pltest;
     422        PULONGLONG plltest;
    419423
    420424        numalloc += 12;
     
    424428          break;
    425429        files = test;
    426         ltest =
    427           xrealloc(cbFile, numalloc * sizeof(ULONG), pszSrcFile, __LINE__);
    428         if (!ltest)
     430        plltest =
     431          xrealloc(pcbFile, numalloc * sizeof(ULONGLONG), pszSrcFile, __LINE__);
     432        if (!plltest)
    429433          break;
    430         cbFile = ltest;
    431         ltest =
    432           xrealloc(ulitemID, numalloc * sizeof(ULONG), pszSrcFile, __LINE__);
    433         if (!ltest)
     434        pcbFile = plltest;
     435        pltest =
     436          xrealloc(pulitemID, numalloc * sizeof(ULONG), pszSrcFile, __LINE__);
     437        if (!pltest)
    434438          break;
    435         ulitemID = ltest;
    436       }
    437       cbFile[numfiles] = 0;
     439        pulitemID = pltest;
     440      }
     441      pcbFile[numfiles] = 0;
    438442      if (!isArc) {
    439443
    440         FILESTATUS4 fsa4;
    441 
    442         if (!DosQueryPathInfo(szFrom, FIL_QUERYEASIZE, &fsa4, sizeof(fsa4)))
    443           cbFile[numfiles] = fsa4.cbFile + CBLIST_TO_EASIZE(fsa4.cbList);
    444       }
    445       ulitemID[numfiles] = pDItem->ulItemID;
     444        FILESTATUS4L fsa4;
     445
     446        if (!DosQueryPathInfo(szFrom, FIL_QUERYEASIZEL, &fsa4, sizeof(fsa4)))
     447          pcbFile[numfiles] = fsa4.cbFile + CBLIST_TO_EASIZE(fsa4.cbList);
     448      }
     449      pulitemID[numfiles] = pDItem->ulItemID;
    446450      files[numfiles] = xstrdup(szFrom, pszSrcFile, __LINE__);
    447451      files[numfiles + 1] = NULL;
     
    464468  } // for curitem
    465469
    466   if (files && numfiles && files[0] && cbFile && ulitemID) {
     470  if (files && numfiles && files[0] && pcbFile && pulitemID) {
    467471    li = xmallocz(sizeof(LISTINFO), pszSrcFile, __LINE__);
    468472    if (li) {
     
    470474      li->hwnd = hwndCnr;
    471475      li->list = files;
    472       li->cbFile = cbFile;
    473       li->ulitemID = ulitemID;
     476      li->cbFile = pcbFile;
     477      li->ulitemID = pulitemID;
    474478      li->hwndS = pDInfo->hwndSource;
    475479      if (!pci && directory)
     
    484488    }
    485489    else {
    486       if (cbFile)
    487         free(cbFile);
    488       if (ulitemID)
    489         free(ulitemID);
     490      xfree(pcbFile);
     491      xfree(pulitemID);
    490492      if (files)
    491493        FreeList(files);
     
    493495  }
    494496  else {
    495     if (cbFile)
    496       free(cbFile);
    497     if (ulitemID)
    498       free(ulitemID);
     497    xfree(pcbFile);
     498    xfree(pulitemID);
    499499    if (files)
    500500      FreeList(files);
  • TabularUnified trunk/dll/eas.c

    r827 r841  
    2727#define INCL_DOS
    2828#define INCL_DOSERRORS
     29#define INCL_LONGLONG
    2930#include <os2.h>
    3031
     
    11851186
    11861187  HOLDFEA *head = NULL, *info, *last = NULL;
    1187   FILESTATUS4 fsa4;
     1188  FILESTATUS4L fsa4;
    11881189  HFILE handle;
    11891190  ULONG action;
     
    11921193  if (!filename)
    11931194    return head;
    1194   if (ishandle || !DosOpen(filename, &handle, &action, 0, 0,
    1195                            OPEN_ACTION_FAIL_IF_NEW |
    1196                            OPEN_ACTION_OPEN_IF_EXISTS,
    1197                            OPEN_FLAGS_NOINHERIT |
    1198                            OPEN_SHARE_DENYREADWRITE |
    1199                            OPEN_ACCESS_READWRITE, (PEAOP2)0)) {
     1195  if (ishandle || !DosOpenL(filename, &handle, &action, 0, 0,
     1196                            OPEN_ACTION_FAIL_IF_NEW |
     1197                            OPEN_ACTION_OPEN_IF_EXISTS,
     1198                            OPEN_FLAGS_NOINHERIT |
     1199                            OPEN_SHARE_DENYREADWRITE |
     1200                            OPEN_ACCESS_READWRITE, (PEAOP2)0)) {
    12001201    if (ishandle)
    12011202      handle = *(HFILE *) filename;
    1202     if (!DosQueryFileInfo(handle, FIL_QUERYEASIZE, (PVOID)&fsa4,
     1203    if (!DosQueryFileInfo(handle, FIL_QUERYEASIZEL, (PVOID)&fsa4,
    12031204                          (ULONG) sizeof(fsa4)) &&
    12041205        fsa4.cbList > 4)
     
    12901291    //03 AUG 07 GKY This isn't an error it is for processing Readonly files
    12911292    /* try it without opening it */
    1292     if (!DosQueryPathInfo(filename, FIL_QUERYEASIZE, (PVOID) & fsa4,
     1293    if (!DosQueryPathInfo(filename, FIL_QUERYEASIZEL, (PVOID) & fsa4,
    12931294                          (ULONG) sizeof(fsa4)) &&
    12941295        fsa4.cbList > 4)
  • TabularUnified trunk/dll/filldir.c

    r838 r841  
    235235                              PCNRITEM pci,
    236236                              const PSZ pszDirectory,
    237                               const PFILEFINDBUF4 pffb,
     237                              const PFILEFINDBUF4L pffb,
    238238                              const BOOL partial,
    239239                              DIRCNRDATA *dcd)
    240240{
    241   // fill in a container record from a FILEFINDBUF4 structure
     241  // fill in a container record from a FILEFINDBUF4L structure
    242242
    243243  CHAR *p;
     
    477477} // FillInRecordFromFFB
    478478
    479 ULONGLONG FillInRecordFromFSA(HWND hwndCnr, PCNRITEM pci, const PSZ pszFileName, const PFILESTATUS4 pfsa4, const BOOL partial, DIRCNRDATA * dcd)        // Optional
     479ULONGLONG FillInRecordFromFSA(HWND hwndCnr, PCNRITEM pci,
     480                              const PSZ pszFileName,
     481                              const PFILESTATUS4L pfsa4,
     482                              const BOOL partial, DIRCNRDATA * dcd)     // Optional
    480483{
    481484  HPOINTER hptr;
    482485  CHAR *p;
    483486
    484   // fill in a container record from a FILESTATUS4 structure
     487  // fill in a container record from a FILESTATUS4L structure
    485488
    486489  pci->hwndCnr = hwndCnr;
     
    490493  // load the object's Subject, if required
    491494  pci->pszSubject = NullStr;
    492   if (pfsa4->cbList > 4L &&
     495  if (pfsa4->cbList > 4 &&
    493496      dcd &&
    494497      fLoadSubject &&
     
    701704  PSZ pszFileSpec;
    702705  INT t;
    703   PFILEFINDBUF4 paffbFound;
    704   PFILEFINDBUF4 *papffbSelected;
    705   PFILEFINDBUF4 pffbFile;
    706   PFILEFINDBUF4 paffbTotal = NULL;
    707   PFILEFINDBUF4 paffbTemp;
     706  PFILEFINDBUF4L paffbFound;
     707  PFILEFINDBUF4L *papffbSelected;
     708  PFILEFINDBUF4L pffbFile;
     709  PFILEFINDBUF4L paffbTotal = NULL;
     710  PFILEFINDBUF4L paffbTemp;
    708711  HDIR hdir = HDIR_CREATE;
    709712  ULONG ulFindCnt;
     
    736739  }
    737740  if (OS2ver[0] == 20 && OS2ver[1] < 30)
    738     ulFindMax = min(ulFindMax, (65535 / sizeof(FILEFINDBUF4)));
    739 
    740   ulBufBytes = ulFindMax * sizeof(FILEFINDBUF4);
     741    ulFindMax = min(ulFindMax, (65535 / sizeof(FILEFINDBUF4L)));
     742
     743  ulBufBytes = ulFindMax * sizeof(FILEFINDBUF4L);
    741744
    742745  pszFileSpec = xmalloc(CCHMAXPATH + 2, pszSrcFile, __LINE__);
    743746  paffbFound = xmalloc(ulBufBytes, pszSrcFile, __LINE__);
    744   papffbSelected = xmalloc(sizeof(PFILEFINDBUF4) * ulFindMax, pszSrcFile, __LINE__);
     747  papffbSelected = xmalloc(sizeof(PFILEFINDBUF4L) * ulFindMax, pszSrcFile, __LINE__);
    745748
    746749  if (paffbFound && papffbSelected && pszFileSpec) {
     
    763766                       ulBufBytes,
    764767                       &ulFindCnt,
    765                        FIL_QUERYEASIZE);
     768                       FIL_QUERYEASIZEL);
    766769    priority_normal();
    767770    *pchEndPath = 0;
     
    804807            break;
    805808          }
    806           pffbFile = (PFILEFINDBUF4)((PBYTE)pffbFile + pffbFile->oNextEntryOffset);
     809          pffbFile = (PFILEFINDBUF4L)((PBYTE)pffbFile + pffbFile->oNextEntryOffset);
    807810        } // for
    808811        if (ulSelCnt) {
     
    868871            // Append newly selected entries to aggregate list
    869872            paffbTemp = xrealloc(paffbTotal,
    870                                  sizeof(FILEFINDBUF4) * (ulSelCnt + ulTotal),
     873                                 sizeof(FILEFINDBUF4L) * (ulSelCnt + ulTotal),
    871874                                 pszSrcFile, __LINE__);
    872875            if (paffbTemp) {
     
    929932            ullTotalBytes += ullBytes;
    930933            // Can not use offset since we have merged lists - this should be equivalent
    931             pffbFile = (PFILEFINDBUF4)((PBYTE)pffbFile + sizeof(FILEFINDBUF4));
     934            pffbFile = (PFILEFINDBUF4L)((PBYTE)pffbFile + sizeof(FILEFINDBUF4L));
    932935          }
    933936          if (ulTotal) {
     
    10371040  CHAR szDrive[] = " :\\";
    10381041  CHAR szFileSystem[CCHMAXPATH];
    1039   FILESTATUS4 fsa4;
     1042  FILESTATUS4L fsa4;
    10401043  APIRET rc;
    10411044  BOOL drivesbuilt = FALSE;
     
    11301133            driveflags[x] |= DRIVE_INVALID;
    11311134
    1132           memset(&fsa4, 0, sizeof(FILESTATUS4));
     1135          memset(&fsa4, 0, sizeof(FILESTATUS4L));
    11331136          driveflags[x] |= removable == -1 || removable == 1 ?
    11341137                            DRIVE_REMOVABLE : 0;
     
    11811184            DosError(FERR_DISABLEHARDERR);
    11821185            rc = DosQueryPathInfo(szDrive,
    1183                                   FIL_QUERYEASIZE,
    1184                                   &fsa4, (ULONG) sizeof(FILESTATUS4));
     1186                                  FIL_QUERYEASIZEL,
     1187                                  &fsa4, (ULONG) sizeof(FILESTATUS4L));
    11851188            // ERROR_BAD_NET_RSP = 58
    11861189            if (rc == 58) {
    11871190              DosError(FERR_DISABLEHARDERR);
    11881191              rc = DosQueryPathInfo(szDrive,
    1189                                     FIL_STANDARD,
    1190                                     &fsa4, (ULONG) sizeof(FILESTATUS3));
     1192                                    FIL_STANDARDL,
     1193                                    &fsa4, (ULONG) sizeof(FILESTATUS3L));
    11911194              fsa4.cbList = 0;
    11921195            }
  • TabularUnified trunk/dll/flesh.c

    r838 r841  
    2626#define INCL_DOSERRORS
    2727#define INCL_WIN
     28#define INCL_LONGLONG
    2829#include <os2.h>
    2930
     
    226227
    227228  BOOL ret = FALSE;
    228   FILEFINDBUF3 ffb[DDEPTH];
    229   PFILEFINDBUF3 pffb;
     229  FILEFINDBUF3L ffb[DDEPTH];
     230  PFILEFINDBUF3L pffb;
    230231  HDIR hDir = HDIR_CREATE;
    231232  ULONG nm, ulM = 1, total = 0, fl = MUST_HAVE_DIRECTORY;
     
    289290                     FILE_READONLY | FILE_ARCHIVED |
    290291                     FILE_SYSTEM | FILE_HIDDEN,
    291                      &ffb, ulM * sizeof(FILEFINDBUF3), &nm, FIL_STANDARD);
     292                     &ffb, ulM * sizeof(FILEFINDBUF3L), &nm, FIL_STANDARDL);
    292293  if (ulM == 1 && !rc) {
    293294    do {
     
    336337    } while (++total < ddepth && !(rc = (xDosFindNext(hDir,
    337338                                                      &ffb,
    338                                                       sizeof(FILEFINDBUF3),
     339                                                      sizeof(FILEFINDBUF3L),
    339340                                                      &nm))));
    340341    DosFindClose(hDir);
     
    364365
    365366      for (len = 0; len < nm; len++) {
    366         pffb = (PFILEFINDBUF3) fb;
     367        pffb = (PFILEFINDBUF3L) fb;
    367368        if (!includefiles && !(pffb->attrFile & FILE_DIRECTORY)) {
    368369          if (!isbroken) {
  • TabularUnified trunk/dll/fm3dll.def

    r828 r841  
    284284         _FM3DllHandle                                .266,
    285285         RootName_                                    .267,
    286          RunFM2Util_                                  .268
     286         RunFM2Util_                                  .268,
     287         xDosFindFirst_                               .269,
     288         xDosFindNext_                                .270
     289
  • TabularUnified trunk/dll/fm3dll.h

    r838 r841  
    352352  CHAR **list;
    353353  ULONG *ulitemID;
    354   ULONG *cbFile;
     354  ULONGLONG *cbFile;
    355355  CHAR targetpath[CCHMAXPATH + 6];
    356356  CHAR arcname[CCHMAXPATH];
     
    412412#define ARCFLAGS_PSEUDODIR  0x00000002
    413413
    414 #define CBLIST_TO_EASIZE(cb) ((cb) > 4 ? (cb) / 2 : 0)  // FILEFINDBUF4.cbList to logical EA size
     414#define CBLIST_TO_EASIZE(cb) ((cb) > 4 ? (cb) / 2 : 0)  // FILEFINDBUF4L.cbList to logical EA size
    415415
    416416typedef struct _CNRITEM
     
    446446  CDATE date;                   // if we know date format
    447447  CTIME time;                   // if we know time format
    448   ULONG cbFile;                 // File's original size
    449   ULONG cbComp;                 // File's compressed size
     448  ULONGLONG cbFile;             // File's original size
     449  ULONGLONG cbComp;             // File's compressed size
    450450  ULONG flags;
    451451}
     
    457457{
    458458  ULONG attrFile;
    459   ULONG cbFile;
    460   ULONG easize;
     459  ULONGLONG cbFile;
     460  ULONGLONG easize;
    461461  FDATE date;
    462462  FTIME time;
     
    643643ULONGLONG FillInRecordFromFFB(HWND hwndCnr, PCNRITEM pci,
    644644                              const PSZ pszDirectory,
    645                               const PFILEFINDBUF4 pffb, const BOOL partial,
     645                              const PFILEFINDBUF4L pffb, const BOOL partial,
    646646                              DIRCNRDATA *pdcd);
    647647ULONGLONG FillInRecordFromFSA(HWND hwndCnr, PCNRITEM pci,
    648                               const PSZ pszFileName, const PFILESTATUS4 pfsa4,
     648                              const PSZ pszFileName, const PFILESTATUS4L pfsa4,
    649649                              const BOOL partial, DIRCNRDATA *pdcd);
    650650VOID FreeCnrItem(HWND hwnd, PCNRITEM pci);
     
    932932/* makelist.c */
    933933INT AddToList(CHAR * string, CHAR *** list, INT * numfiles, INT * numalloced);
    934 INT AddToFileList(CHAR * string, FILEFINDBUF4 * ffb4, FILELIST *** list,
     934INT AddToFileList(CHAR * string, FILEFINDBUF4L * ffb4, FILELIST *** list,
    935935                  INT * numfiles, INT * numalloced);
    936936CHAR **BuildList(HWND hwndCnr);
     
    13181318
    13191319/* wrappers.c */
    1320 APIRET APIENTRY  xDosFindFirst(PSZ    pszFileSpec,
    1321                                PHDIR phdir,
    1322                                ULONG  flAttribute,
    1323                                PVOID  pfindbuf,
    1324                                ULONG  cbBuf,
    1325                                PULONG pcFileNames,
    1326                                ULONG  ulInfoLevel);
    1327 APIRET APIENTRY  xDosFindNext(HDIR   hDir,
    1328                               PVOID  pfindbuf,
    1329                               ULONG  cbfindbuf,
    1330                               PULONG pcFilenames);
    1331 APIRET APIENTRY  xDosSetPathInfo(PSZ   pszPathName,
    1332                                  ULONG ulInfoLevel,
    1333                                  PVOID pInfoBuf,
    1334                                  ULONG cbInfoBuf,
    1335                                  ULONG flOptions);
     1320APIRET xDosFindFirst(PSZ pszFileSpec,
     1321                     PHDIR phdir,
     1322                     ULONG  flAttribute,
     1323                     PVOID  pfindbuf,
     1324                     ULONG  cbBuf,
     1325                     PULONG pcFileNames,
     1326                     ULONG  ulInfoLevel);
     1327APIRET xDosFindNext(HDIR   hDir,
     1328                    PVOID  pfindbuf,
     1329                    ULONG  cbfindbuf,
     1330                    PULONG pcFilenames);
     1331APIRET xDosSetPathInfo(PSZ   pszPathName,
     1332                       ULONG ulInfoLevel,
     1333                       PVOID pInfoBuf,
     1334                       ULONG cbInfoBuf,
     1335                       ULONG flOptions);
    13361336PSZ xfgets(PSZ pszBuf, size_t cMaxBytes, FILE * fp, PCSZ pszSrcFile,
    13371337           UINT uiLineNumber);
  • TabularUnified trunk/dll/fsopen.c

    r689 r841  
    1818#define INCL_WIN
    1919#define INCL_DOS
     20#define INCL_LONGLONG
    2021
    2122#include <os2.h>
     
    3334{
    3435
    35   ULONG openflag = OPEN_ACTION_OPEN_IF_EXISTS, openmode = 0, action = 0;
     36  ULONG openflag = OPEN_ACTION_OPEN_IF_EXISTS, openmode = 0;
     37  ULONGLONG action = 0;
    3638  HFILE handle;
    3739  FILE *fp;
     
    6668  else
    6769    openmode |= OPEN_FLAGS_RANDOMSEQUENTIAL;
    68   if (DosOpen(filename, &handle, &action, 0L, FILE_NORMAL, openflag, openmode,
    69               (PEAOP2) 0))
     70  if (DosOpenL(filename, &handle, &action, 0, FILE_NORMAL, openflag, openmode,
     71               (PEAOP2) 0))
    7072    return NULL;
    7173  if (mode[strlen(mode) - 1] == 't')
  • TabularUnified trunk/dll/getnames.c

    r838 r841  
    1616#define INCL_DOS
    1717#define INCL_WIN
     18#define INCL_LONGLONG
    1819#include <os2.h>
    1920
     
    3940      ULONG ulDriveNum, ulDriveMap;
    4041      ULONG ulSearchCount;
    41       FILEFINDBUF3 findbuf;
     42      FILEFINDBUF3L findbuf;
    4243      HDIR hDir;
    4344      APIRET rc;
     
    5859                               MUST_HAVE_DIRECTORY | FILE_READONLY |
    5960                               FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
    60                                &findbuf, sizeof(FILEFINDBUF3),
    61                                &ulSearchCount, FIL_STANDARD);
     61                               &findbuf, sizeof(FILEFINDBUF3L),
     62                               &ulSearchCount, FIL_STANDARDL);
    6263          else {
    6364            rc = 0;
     
    209210{
    210211  FILEDLG fdlg;
    211   FILESTATUS3 fsa;
     212  FILESTATUS3L fsa;
    212213  CHAR drive[3], *pdrive = drive, *p;
    213214  APIRET rc;
     
    277278    return FALSE;
    278279  MakeFullName(filename);
    279   if (!DosQueryPathInfo(filename, FIL_STANDARD, &fsa, sizeof(fsa))) {
     280  if (!DosQueryPathInfo(filename, FIL_STANDARDL, &fsa, sizeof(fsa))) {
    280281    if (fsa.attrFile & FILE_DIRECTORY) {
    281282      /* device or directory */
     
    284285      return FALSE;
    285286    }
    286     else if (fsa.cbFile == 0L) {
     287    else if (fsa.cbFile == 0) {
    287288      saymsg(MB_CANCEL,
    288289             hwnd, filename, GetPString(IDS_ISZEROLENGTHTEXT), filename);
     
    315316{
    316317  FILEDLG fdlg;
    317   FILESTATUS3 fsa;
     318  FILESTATUS3L fsa;
    318319  CHAR drive[3], *pdrive = drive, *p;
    319320  static CHAR lastfilename[CCHMAXPATH] = "";
     
    368369    return FALSE;
    369370  MakeFullName(filename);
    370   if (!DosQueryPathInfo(filename, FIL_STANDARD, &fsa, sizeof(fsa))) {
     371  if (!DosQueryPathInfo(filename, FIL_STANDARDL, &fsa, sizeof(fsa))) {
    371372    if (fsa.attrFile & FILE_DIRECTORY) {        /* device or directory */
    372373      saymsg(MB_CANCEL | MB_ICONEXCLAMATION,
  • TabularUnified trunk/dll/grep.c

    r839 r841  
    5353                         char **fle, int numfls);
    5454static INT domatchingfiles(GREP *grep, CHAR *path, char **fle, int numfls);
    55 static BOOL doonefile(GREP *grep, CHAR *fileName, FILEFINDBUF4 *pffb);
     55static BOOL doonefile(GREP *grep, CHAR *fileName, FILEFINDBUF4L *pffb);
    5656static BOOL doinsertion(GREP *grep);
    57 static BOOL InsertDupe(GREP *grep, CHAR *dir, FILEFINDBUF4 *pffb);
     57static BOOL InsertDupe(GREP *grep, CHAR *dir, FILEFINDBUF4L *pffb);
    5858static VOID FillDupes(GREP *grep);
    5959static VOID FreeDupes(GREP *grep);
     
    6868ULONG SecsSince1980(FDATE * date, FTIME * time)
    6969{
    70   ULONG total = 0L;
     70  ULONG total = 0;
    7171  register int x;
    7272
    7373  for (x = 1980; x < date->year + 1980; x++) {
    7474    if (isleap(x))
    75       total += (366L * (24L * 60L * 60L));
     75      total += (366 * (24 * 60 * 60));
    7676    else
    77       total += (365L * (24L * 60L * 60L));
     77      total += (365 * (24 * 60 * 60));
    7878  }
    7979  for (x = 1; x < date->month; x++) {
    8080    if (x == 2 && isleap(date->year + 1980))
    81       total += (29L * (24L * 60L * 60L));
     81      total += (29 * (24 * 60 * 60));
    8282    else
    83       total += ((long)monthdays[x - 1] * (24L * 60L * 60L));
    84   }
    85   total += (((long)date->day - 1L) * (24L * 60L * 60L));
    86   total += ((long)time->hours * (60L * 60L));
    87   total += ((long)time->minutes * 60L);
    88   total += ((long)time->twosecs * 2L);
     83      total += ((long)monthdays[x - 1] * (24 * 60 * 60));
     84  }
     85  total += (((long)date->day - 1) * (24 * 60 * 60));
     86  total += ((long)time->hours * (60 * 60));
     87  total += ((long)time->minutes * 60);
     88  total += ((long)time->twosecs * 2);
    8989  return total;
    9090}
     
    401401  // process all subdirectories
    402402
    403   FILEFINDBUF4 ffb;
     403  FILEFINDBUF4L ffb;
    404404  HDIR findHandle = HDIR_CREATE;
    405405  LONG ulFindCnt = 1;
     
    415415                     FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN | FILE_READONLY),
    416416                     &ffb, (ULONG) sizeof(ffb),
    417                      (PULONG) & ulFindCnt, FIL_QUERYEASIZE)) {
     417                     (PULONG) & ulFindCnt, FIL_QUERYEASIZEL)) {
    418418
    419419    // get rid of mask portion, save end-of-directory
     
    454454  // process all matching files in a directory
    455455
    456   PFILEFINDBUF4 pffbArray;
    457   PFILEFINDBUF4 pffbFile;
     456  PFILEFINDBUF4L pffbArray;
     457  PFILEFINDBUF4L pffbFile;
    458458  ULONG x;
    459459  HDIR findHandle = HDIR_CREATE;
     
    462462  PSZ p;
    463463  APIRET rc;
    464   ULONG ulBufBytes = FilesToGet * sizeof(FILEFINDBUF4);
     464  ULONG ulBufBytes = FilesToGet * sizeof(FILEFINDBUF4L);
    465465  static BOOL fDone;
    466466
     
    494494                     ulBufBytes,
    495495                     &ulFindCnt,
    496                      FIL_QUERYEASIZE);
     496                     FIL_QUERYEASIZEL);
    497497  if (!rc) {
    498498    do {
     
    506506            (pffbFile->achName[1] && pffbFile->achName[1] != '.')) {
    507507          strcpy(p, pffbFile->achName); // build filename
    508           if (strlen(szFindPath) > 256){   //21 Sep GKY check for pathnames that exceed maxpath
     508          if (strlen(szFindPath) > CCHMAXPATH){   //21 Sep GKY check for pathnames that exceed maxpath
    509509            DosFindClose(findHandle);
    510510            free(pffbArray);
     
    530530        if (!pffbFile->oNextEntryOffset)
    531531          break;
    532         pffbFile = (PFILEFINDBUF4)((PBYTE)pffbFile + pffbFile->oNextEntryOffset);
     532        pffbFile = (PFILEFINDBUF4L)((PBYTE)pffbFile + pffbFile->oNextEntryOffset);
    533533      } // for
    534534      if (*grep->stopflag)
     
    621621}
    622622
    623 static BOOL insert_grepfile(GREP *grep, CHAR *filename, PFILEFINDBUF4 pffb)
     623static BOOL insert_grepfile(GREP *grep, CHAR *filename, PFILEFINDBUF4L pffb)
    624624{
    625625  PSZ p;
     
    636636      if (!grep->insertffb) {
    637637        // Allocate 1 extra for end marker?
    638         grep->insertffb = xmallocz(sizeof(PFILEFINDBUF4) * (FilesToGet + 1),
     638        grep->insertffb = xmallocz(sizeof(PFILEFINDBUF4L) * (FilesToGet + 1),
    639639                                   pszSrcFile, __LINE__);
    640640        if (!grep->insertffb)
     
    648648      }
    649649      grep->insertffb[grep->toinsert] =
    650         xmalloc(sizeof(FILEFINDBUF4), pszSrcFile, __LINE__);
     650        xmalloc(sizeof(FILEFINDBUF4L), pszSrcFile, __LINE__);
    651651      if (!grep->insertffb[grep->toinsert])
    652652        return FALSE;
    653       memcpy(grep->insertffb[grep->toinsert], pffb, sizeof(FILEFINDBUF4));
     653      memcpy(grep->insertffb[grep->toinsert], pffb, sizeof(FILEFINDBUF4L));
    654654      grep->dir[grep->toinsert] = xstrdup(szDirectory, pszSrcFile, __LINE__);
    655655      if (!grep->dir) {
     
    669669}
    670670
    671 static BOOL doonefile(GREP *grep, CHAR *filename, FILEFINDBUF4 * pffb)
     671static BOOL doonefile(GREP *grep, CHAR *filename, FILEFINDBUF4L * pffb)
    672672{
    673673  // process a single file
     
    14061406}
    14071407
    1408 static BOOL InsertDupe(GREP *grep, CHAR *dir, FILEFINDBUF4 *pffb)
     1408static BOOL InsertDupe(GREP *grep, CHAR *dir, FILEFINDBUF4L *pffb)
    14091409{
    14101410  DUPES *info;
  • TabularUnified trunk/dll/grep.h

    r785 r841  
    6262  CHAR *stopflag;
    6363  ULONG toinsert;
    64   ULONG insertedbytes;
    65   FILEFINDBUF4 **insertffb;
     64  ULONGLONG insertedbytes;
     65  FILEFINDBUF4L **insertffb;
    6666  CHAR **dir;
    6767  ULONG attrFile;
  • TabularUnified trunk/dll/info.c

    r838 r841  
    623623    if (pfs && *pfs->szFileName) {
    624624      CHAR s[97];
    625       FILEFINDBUF4 fs;
     625      FILEFINDBUF4L fs;
    626626      HDIR hdir = HDIR_CREATE;
    627       ULONG apptype = 1L;
     627      ULONG apptype = 1;
    628628      FILE *fp;
    629629      HPOINTER hptr;
     
    636636                        FILE_DIRECTORY | FILE_READONLY | FILE_HIDDEN |
    637637                        FILE_SYSTEM,
    638                         &fs, sizeof(fs), &apptype, FIL_QUERYEASIZE)) {
     638                        &fs, sizeof(fs), &apptype, FIL_QUERYEASIZEL)) {
    639639        // Not found
    640640        SHORT sSelect, numitems;
  • TabularUnified trunk/dll/inis.c

    r838 r841  
    2727#define INCL_DOS
    2828#define INCL_DOSERRORS
     29#define INCL_LONGLONG
    2930#include <os2.h>
    3031
     
    516517    WinSetWindowText(hwndMLE, lasttext);
    517518    {
    518       FILEFINDBUF3 ffb;
     519      FILEFINDBUF3L ffb;
    519520      ULONG nm;
    520521      HDIR hdir;
     
    526527                         &hdir,
    527528                         FILE_NORMAL | FILE_ARCHIVED,
    528                          &ffb, sizeof(ffb), &nm, FIL_STANDARD)) {
     529                         &ffb, sizeof(ffb), &nm, FIL_STANDARDL)) {
    529530        do {
    530531          priority_bumped();
     
    16181619      CHAR szFrom[CCHMAXPATH + 2], szDir[CCHMAXPATH + 1],
    16191620        szTemp[CCHMAXPATH + 2];
    1620       FILESTATUS3 fsa;
     1621      FILESTATUS3L fsa;
    16211622      INIREC inirec;
    16221623
     
    16371638          else {
    16381639            if (FullDrgName(pDItem, szFrom, sizeof(szFrom)) &&
    1639                 !DosQueryPathInfo(szFrom, FIL_STANDARD, &fsa,
    1640                                   (ULONG) sizeof(FILESTATUS3)))
     1640                !DosQueryPathInfo(szFrom, FIL_STANDARDL, &fsa,
     1641                                  (ULONG) sizeof(FILESTATUS3L)))
    16411642              WinSendMsg(WinQueryWindow(hwnd, QW_PARENT), WM_COMMAND,
    16421643                         MPFROM2SHORT(IDM_COMPARE, 0), MPFROMP(szFrom));
     
    24872488
    24882489        CHAR filename[CCHMAXPATH + 81], *p;
    2489         FILESTATUS3 fsa;
     2490        FILESTATUS3L fsa;
    24902491        HINI hINI;
    24912492
     
    25102511                            TRUE) &&
    25112512            *filename &&
    2512             !DosQueryPathInfo(filename, FIL_STANDARD, &fsa, sizeof(fsa))) {
     2513            !DosQueryPathInfo(filename, FIL_STANDARDL, &fsa, sizeof(fsa))) {
    25132514          hINI = PrfOpenProfile(WinQueryAnchorBlock(hwnd), filename);
    25142515          if (!hINI) {
  • TabularUnified trunk/dll/init.c

    r838 r841  
    5252#define INCL_GPI
    5353#define INCL_DOSERRORS
     54#define INCL_LONGLONG
    5455#include <os2.h>
    5556#include <os2me.h>
     
    8182  CHAR *pp;
    8283  FILE *fp;
    83   FILEFINDBUF3 ffb;
     84  FILEFINDBUF3L ffb;
    8485  ULONG nm;
    8586  ULONG size = sizeof(SwapperDat);
     
    9697                       FILE_NORMAL | FILE_ARCHIVED |
    9798                       FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
    98                        &ffb, sizeof(ffb), &nm, FIL_STANDARD);
     99                       &ffb, sizeof(ffb), &nm, FIL_STANDARDL);
    99100    if (!rc) {
    100101      DosFindClose(hdir);
     
    157158                                 FILE_NORMAL | FILE_ARCHIVED |
    158159                                 FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
    159                                  &ffb, sizeof(ffb), &nm, FIL_STANDARD)) {
     160                                 &ffb, sizeof(ffb), &nm, FIL_STANDARDL)) {
    160161                DosFindClose(hdir);
    161162                PrfWriteProfileString(fmprof,
     
    181182  CHAR *env;
    182183  CHAR stringfile[CCHMAXPATH];
    183   FILESTATUS3 fsa;
     184  FILESTATUS3L fsa;
    184185  APIRET rc;
    185186
     
    194195    if (env) {
    195196      DosError(FERR_DISABLEHARDERR);
    196       rc = DosQueryPathInfo(env, FIL_STANDARD, &fsa, sizeof(fsa));
     197      rc = DosQueryPathInfo(env, FIL_STANDARDL, &fsa, sizeof(fsa));
    197198      if (!rc) {
    198199        if (fsa.attrFile & FILE_DIRECTORY) {
    199200          BldFullPathName(stringfile, env, "FM3RES.STR");
    200201          DosError(FERR_DISABLEHARDERR);
    201           if (DosQueryPathInfo(stringfile, FIL_STANDARD, &fsa, sizeof(fsa)))
     202          if (DosQueryPathInfo(stringfile, FIL_STANDARDL, &fsa, sizeof(fsa)))
    202203            strcpy(stringfile, "FM3RES.STR");
    203204        }
     
    295296  CHAR *env;
    296297  CHAR stringfile[CCHMAXPATH];
    297   FILESTATUS3 fsa;
     298  FILESTATUS3L fsa;
    298299  APIRET rc;
    299300
     
    307308    if (env) {
    308309      DosError(FERR_DISABLEHARDERR);
    309       rc = DosQueryPathInfo(env, FIL_STANDARD, &fsa, sizeof(fsa));
     310      rc = DosQueryPathInfo(env, FIL_STANDARDL, &fsa, sizeof(fsa));
    310311      if (!rc) {
    311312        if (fsa.attrFile & FILE_DIRECTORY) {
    312313          BldFullPathName(stringfile, env, "FM3RES.STR");
    313314          DosError(FERR_DISABLEHARDERR);
    314           if (DosQueryPathInfo(stringfile, FIL_STANDARD, &fsa, sizeof(fsa)))
     315          if (DosQueryPathInfo(stringfile, FIL_STANDARDL, &fsa, sizeof(fsa)))
    315316            strcpy(stringfile, "FM3RES.STR");
    316317        }
     
    409410  HDIR search_handle;
    410411  ULONG num_matches;
    411   static FILEFINDBUF3 f;
     412  static FILEFINDBUF3L f;
    412413
    413414  StopTimer();
     
    449450                       FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN |
    450451                       FILE_ARCHIVED,
    451                        &f, sizeof(FILEFINDBUF3), &num_matches, FIL_STANDARD)) {
     452                       &f, sizeof(FILEFINDBUF3L), &num_matches, FIL_STANDARDL)) {
    452453      do {
    453454        strcpy(enddir, f.achName);
     
    460461      }
    461462      while (!xDosFindNext(search_handle,
    462                            &f, sizeof(FILEFINDBUF3), &num_matches));
     463                           &f, sizeof(FILEFINDBUF3L), &num_matches));
    463464      DosFindClose(search_handle);
    464465    }
     
    478479                     FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN |
    479480                     FILE_ARCHIVED,
    480                      &f, sizeof(FILEFINDBUF3), &num_matches, FIL_STANDARD)) {
     481                     &f, sizeof(FILEFINDBUF3L), &num_matches, FIL_STANDARDL)) {
    481482    do {
    482483      if (!(f.attrFile & FILE_DIRECTORY)) {
     
    486487    }
    487488    while (!xDosFindNext(search_handle,
    488                          &f, sizeof(FILEFINDBUF3), &num_matches));
     489                         &f, sizeof(FILEFINDBUF3L), &num_matches));
    489490    DosFindClose(search_handle);
    490491  }
     
    515516  ULONG RVMinor = 0;
    516517  ULONG ret = 0;
    517   FILESTATUS3 fs3;                      // 25 Aug 07 SHL
     518  FILESTATUS3L fs3;                     // 25 Aug 07 SHL
    518519  PSZ env;
    519520  CHAR dllfile[CCHMAXPATH];
     
    533534  if (env) {
    534535    DosError(FERR_DISABLEHARDERR);
    535     rc = DosQueryPathInfo(env, FIL_STANDARD, &fs3, sizeof(fs3));
     536    rc = DosQueryPathInfo(env, FIL_STANDARDL, &fs3, sizeof(fs3));
    536537    if (!rc) {
    537538      if (fs3.attrFile & FILE_DIRECTORY) {
    538539        BldFullPathName(dllfile, env, "FM3RES");        // 23 Aug 07 SHL
    539540        DosError(FERR_DISABLEHARDERR);
    540         if (DosQueryPathInfo(dllfile, FIL_STANDARD, (PVOID)&fs3, (ULONG)sizeof(fs3)))
     541        if (DosQueryPathInfo(dllfile, FIL_STANDARDL, (PVOID)&fs3, (ULONG)sizeof(fs3)))
    541542          strcpy(dllfile, "FM3RES");
    542543      }
     
    648649      strcpy(inipath, env);
    649650      DosError(FERR_DISABLEHARDERR);
    650       rc = DosQueryPathInfo(inipath, FIL_STANDARD, &fs3, sizeof(fs3));
     651      rc = DosQueryPathInfo(inipath, FIL_STANDARDL, &fs3, sizeof(fs3));
    651652      if (!rc) {
    652653        if (fs3.attrFile & FILE_DIRECTORY)
     
    667668    DosError(FERR_DISABLEHARDERR);
    668669
    669     if (!DosQueryPathInfo(inipath, FIL_STANDARD, &fs3, sizeof(fs3))) {
     670    if (!DosQueryPathInfo(inipath, FIL_STANDARDL, &fs3, sizeof(fs3))) {
    670671      fIniExisted = TRUE;
    671672      if (fs3.attrFile & (FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM)) {
    672673        fs3.attrFile &= ~(FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM);
    673         rc = xDosSetPathInfo(inipath, FIL_STANDARD, &fs3, sizeof(fs3), 0);
     674        rc = xDosSetPathInfo(inipath, FIL_STANDARDL, &fs3, sizeof(fs3), 0);
    674675        if (rc) {
    675676          Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
     
    724725      strcpy(helppath, env);
    725726      DosError(FERR_DISABLEHARDERR);
    726       rc = DosQueryPathInfo(helppath, FIL_STANDARD, &fs3, sizeof(fs3));
     727      rc = DosQueryPathInfo(helppath, FIL_STANDARDL, &fs3, sizeof(fs3));
    727728      if (!rc) {
    728729        if (fs3.attrFile & FILE_DIRECTORY) {
  • TabularUnified trunk/dll/mainwnd.c

    r838 r841  
    55935593      ULONG ulSearchCount;
    55945594      SHORT sSelect;
    5595       FILEFINDBUF3 findbuf;
     5595      FILEFINDBUF3L findbuf;
    55965596      HDIR hDir;
    55975597      CHAR *p;
     
    56015601      ulSearchCount = 1;
    56025602      if (!xDosFindFirst("*.TLS", &hDir, FILE_READONLY | FILE_ARCHIVED,
    5603                          &findbuf, sizeof(FILEFINDBUF3),
    5604                          &ulSearchCount, FIL_STANDARD)) {
     5603                         &findbuf, sizeof(FILEFINDBUF3L),
     5604                         &ulSearchCount, FIL_STANDARDL)) {
    56055605        do {
    56065606          priority_bumped();
     
    56275627          }
    56285628        }
    5629         while (!xDosFindNext(hDir, &findbuf, sizeof(FILEFINDBUF3),
     5629        while (!xDosFindNext(hDir, &findbuf, sizeof(FILEFINDBUF3L),
    56305630                             &ulSearchCount));
    56315631        DosFindClose(hDir);
     
    56425642      ULONG ulDriveMap;
    56435643      ULONG ulSearchCount;
    5644       FILEFINDBUF3 findbuf;
     5644      FILEFINDBUF3L findbuf;
    56455645      HDIR hDir;
    56465646      APIRET rc;
     
    56645664                               MUST_HAVE_DIRECTORY | FILE_READONLY |
    56655665                               FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
    5666                                &findbuf, sizeof(FILEFINDBUF3),
    5667                                &ulSearchCount, FIL_STANDARD);
     5666                               &findbuf, sizeof(FILEFINDBUF3L),
     5667                               &ulSearchCount, FIL_STANDARDL);
    56685668          else {
    56695669            rc = 0;
     
    57065706                               MUST_HAVE_DIRECTORY | FILE_READONLY |
    57075707                               FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
    5708                                &findbuf, sizeof(FILEFINDBUF3),
    5709                                &ulSearchCount, FIL_STANDARD);
     5708                               &findbuf, sizeof(FILEFINDBUF3L),
     5709                               &ulSearchCount, FIL_STANDARDL);
    57105710          else {
    57115711            rc = 0;
  • TabularUnified trunk/dll/mainwnd2.c

    r793 r841  
    2626#define INCL_WIN
    2727#define INCL_GPI
     28#define INCL_LONGLONG
    2829#include <os2.h>
    2930
     
    13621363  {
    13631364    CHAR inipath[CCHMAXPATH], fullpath[CCHMAXPATH];
    1364     FILESTATUS3 fsa;
     1365    FILESTATUS3L fsa;
    13651366
    13661367    if (PrfQueryProfileString(HINI_USERPROFILE,
    13671368                              FM2Str,
    13681369                              "Home", NULL, inipath, sizeof(inipath))) {
    1369       if (!DosQueryPathInfo(inipath, FIL_STANDARD, &fsa, (ULONG) sizeof(fsa))) {
     1370      if (!DosQueryPathInfo(inipath, FIL_STANDARDL, &fsa, (ULONG) sizeof(fsa))) {
    13701371        if (fsa.attrFile & FILE_DIRECTORY) {
    13711372          if (DosQueryPathInfo(inipath,
  • TabularUnified trunk/dll/makefile

    r833 r841  
    3232# 26 Aug 07 SHL Clean *.lrf
    3333# 05 Sep 07 SHL Correct USE_WRC logic
     34# 22 Sep 07 SHL Switch to 4 byte packing (-zp4)
    3435
    3536# Environment:
     
    99100
    100101!ifdef DEBUG
    101 CFLAGS =  -bt=os2 -mf -bd -bm -hd -d2 -olirs -s -sg -j -wx -zfp -zgp -zq
    102 CFLAGS =  -bt=os2 -mf -bd -bm -hd -d2        -s -sg -j -wx -zfp -zgp -zq
    103 !else
    104 CFLAGS =  -bt=os2 -mf -bd -bm -hd -d1 -olirs -s -sg -j -wx -zfp -zgp -zq
     102CFLAGS =  -bt=os2 -mf -bd -bm -hd -d2 -olirs -s -sg -j -wx -zfp -zgp -zp4 -zq
     103CFLAGS =  -bt=os2 -mf -bd -bm -hd -d2        -s -sg -j -wx -zfp -zgp -zp4 -zq
     104!else
     105CFLAGS =  -bt=os2 -mf -bd -bm -hd -d1 -olirs -s -sg -j -wx -zfp -zgp -zp4 -zq
    105106!endif
    106107
    107108# for fm3res only
    108 CFLAGSR = -bt=os2 -mf -bd -bm         -olirs -s     -j -wx -zfp -zgp -zq
     109CFLAGSR = -bt=os2 -mf -bd -bm         -olirs -s     -j -wx -zfp -zgp -zp4 -zq
    109110
    110111!ifdef DEBUG
  • TabularUnified trunk/dll/makelist.c

    r793 r841  
    1919#define INCL_DOS
    2020#define INCL_WIN
     21#define INCL_LONGLONG
    2122#include <os2.h>
    2223
     
    9596}
    9697
    97 INT AddToFileList(CHAR * string, FILEFINDBUF4 * ffb4, FILELIST *** list,
     98INT AddToFileList(CHAR * string, FILEFINDBUF4L * ffb4, FILELIST *** list,
    9899                  INT * numfiles, INT * numalloced)
    99100{
  • TabularUnified trunk/dll/misc.c

    r827 r841  
    4040#define INCL_WIN
    4141#define INCL_GPI
     42#define INCL_LONGLONG
    4243#include <os2.h>
    4344
  • TabularUnified trunk/dll/mle.c

    r814 r841  
    2222#define INCL_DOS
    2323#define INCL_WIN
     24#define INCL_LONGLONG
    2425#include <os2.h>
    2526
     
    429430  HAB hab;
    430431  CHAR *buffer = NULL, *hexbuff = NULL;
    431   IPT iptOffset = -1L;
    432   ULONG numread, howmuch, numimport, action, len, left = 0L;
     432  IPT iptOffset = -1;
     433  ULONG numread, howmuch, numimport, action, len, left = 0;
    433434  BOOL ret = TRUE, first = TRUE;
    434435  CHAR titletext[512];
     
    446447  *titletext = 0;
    447448  WinQueryWindowText(grandpa, 512, titletext);
    448   rc = DosOpen(filename, &handle, &action, 0L, 0L,
    449                OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
    450                OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
    451                OPEN_FLAGS_SEQUENTIAL | OPEN_SHARE_DENYNONE |
    452                OPEN_ACCESS_READONLY, 0L);
     449  rc = DosOpenL(filename, &handle, &action, 0, 0,
     450                OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
     451                OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
     452                OPEN_FLAGS_SEQUENTIAL | OPEN_SHARE_DENYNONE |
     453                OPEN_ACCESS_READONLY, 0);
    453454  if (rc) {
    454455    ret = FALSE;
    455456  }
    456457  else {
    457     DosChgFilePtr(handle, 0L, FILE_END, &len);
    458     DosChgFilePtr(handle, 0L, FILE_BEGIN, &action);
     458    DosChgFilePtr(handle, 0, FILE_END, &len);
     459    DosChgFilePtr(handle, 0, FILE_BEGIN, &action);
    459460    if (len) {
    460       rc = DosAllocMem((PVOID) & hexbuff, 50001L,
     461      rc = DosAllocMem((PVOID) & hexbuff, 50001,
    461462                       PAG_COMMIT | OBJ_TILE | PAG_READ | PAG_WRITE);
    462463      if (rc || !hexbuff) {
     
    774775   */
    775776
    776   FILESTATUS3 fsa;
     777  FILESTATUS3L fsa;
    777778  BOOL ret;
    778779
    779   if (!DosQueryPathInfo(filename, FIL_STANDARD, &fsa, (ULONG) sizeof(fsa)) &&
     780  if (!DosQueryPathInfo(filename, FIL_STANDARDL, &fsa, (ULONG) sizeof(fsa)) &&
    780781      !(fsa.attrFile & FILE_DIRECTORY)) {
    781782    MLEclearall(h);
  • TabularUnified trunk/dll/newview.c

    r819 r841  
    3131#define INCL_WIN
    3232#define INCL_GPI
     33#define INCL_LONGLONG
    3334#include <os2.h>
    3435
     
    12571258  VIEWDATA *ad;
    12581259  HFILE handle;
    1259   ULONG action, len;
     1260  ULONG action;
     1261  ULONG len;
    12601262  APIRET rc;
    12611263  BOOL error = TRUE;
     
    12891291                    MPFROMLONG(FCF_SIZEBORDER), MPVOID);
    12901292            WinSetFocus(HWND_DESKTOP, hwnd);
    1291             rc = DosOpen(ad->filename, &handle, &action, 0L, 0L,
    1292                          OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
    1293                          OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
    1294                          OPEN_FLAGS_SEQUENTIAL | OPEN_SHARE_DENYNONE |
    1295                          OPEN_ACCESS_READONLY, 0L);
     1293            rc = DosOpenL(ad->filename, &handle, &action, 0, 0,
     1294                          OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
     1295                          OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
     1296                          OPEN_FLAGS_SEQUENTIAL | OPEN_SHARE_DENYNONE |
     1297                          OPEN_ACCESS_READONLY, 0);
    12961298            if (rc) {
    12971299              Dos_Error(MB_CANCEL,
     
    13031305            }
    13041306            else {
    1305               DosChgFilePtr(handle, 0L, FILE_END, &len);
    1306               DosChgFilePtr(handle, 0L, FILE_BEGIN, &action);
     1307              DosChgFilePtr(handle, 0, FILE_END, &len);
     1308              DosChgFilePtr(handle, 0, FILE_BEGIN, &action);
    13071309              if (!len) {
    13081310                saymsg(MB_CANCEL,
  • TabularUnified trunk/dll/objcnr.c

    r838 r841  
    2727#define INCL_WIN
    2828#define INCL_DOSERRORS
     29#define INCL_LONGLONG
    2930#include <os2.h>
    3031
     
    7172  ULONG ulBufBytes;
    7273  HDIR hdir;
    73   PFILEFINDBUF3 pffbArray;
     74  PFILEFINDBUF3L pffbArray;
    7475  APIRET rc;
    7576  RECORDINSERT ri;
     
    7778  HPOINTER hptr;
    7879
    79   ulBufBytes = sizeof(FILEFINDBUF3) * FilesToGet;
     80  ulBufBytes = sizeof(FILEFINDBUF3L) * FilesToGet;
    8081  pffbArray = xmalloc(ulBufBytes, pszSrcFile, __LINE__);
    8182  if (!pffbArray)
     
    9192                     FILE_NORMAL | FILE_READONLY | FILE_ARCHIVED |
    9293                     FILE_SYSTEM | FILE_HIDDEN | MUST_HAVE_DIRECTORY,
    93                      pffbArray, ulBufBytes, &ulFindCnt, FIL_STANDARD);
     94                     pffbArray, ulBufBytes, &ulFindCnt, FIL_STANDARDL);
    9495  if (!rc)
    9596    DosFindClose(hdir);
     
    164165                     FILE_NORMAL | FILE_READONLY | FILE_ARCHIVED |
    165166                     FILE_SYSTEM | FILE_HIDDEN | MUST_HAVE_DIRECTORY,
    166                      pffbArray, ulBufBytes, &ulFindCnt, FIL_STANDARD);
     167                     pffbArray, ulBufBytes, &ulFindCnt, FIL_STANDARDL);
    167168  if (!rc) {
    168     PFILEFINDBUF3 pffbFile;
     169    PFILEFINDBUF3L pffbFile;
    169170    ULONG x;
    170171
     
    184185        if (!pffbFile->oNextEntryOffset)
    185186          break;
    186         pffbFile = (PFILEFINDBUF3)((PBYTE)pffbFile + pffbFile->oNextEntryOffset);
     187        pffbFile = (PFILEFINDBUF3L)((PBYTE)pffbFile + pffbFile->oNextEntryOffset);
    187188      } // for
    188189      DosSleep(0);                      // Let's others at same priority get some work done
  • TabularUnified trunk/dll/printer.c

    r793 r841  
    2020#define INCL_DOS
    2121#define INCL_WIN
     22#define INCL_LONGLONG
    2223
    2324#include <os2.h>
     
    9697  FILE *fpi, *fpo;
    9798  CHAR s[CCHMAXPATH + 80];
    98   FILESTATUS3 fs3;
     99  FILESTATUS3L fs3;
    99100  LONG cols, lines, pages, z, lmargin, rmargin;
    100101  BOOL endline, endpage, startpage, skipping, firstpass;
     
    125126          DosError(FERR_DISABLEHARDERR);
    126127          if (DosQueryPathInfo
    127               (li->list[x], FIL_STANDARD, &fs3, (ULONG) sizeof(fs3))
     128              (li->list[x], FIL_STANDARDL, &fs3, (ULONG) sizeof(fs3))
    128129              || (fs3.attrFile & FILE_DIRECTORY) || !fs3.cbFile)
    129130            continue;
  • TabularUnified trunk/dll/rename.c

    r793 r841  
    1616#define INCL_DOS
    1717#define INCL_WIN
     18#define INCL_LONGLONG
    1819
    1920#include <os2.h>
     
    7677      if (mv) {
    7778
    78         FILESTATUS3 fs1, fs2;
     79        FILESTATUS3L fs1, fs2;
    7980        CHAR s[CCHMAXPATH * 2], *p, chkname[CCHMAXPATH];
    8081        INT sourceexists = 0, targetexists = 0,
     
    9192        if (!MakeFullName(mv->source))
    9293          WinSetDlgItemText(hwnd, REN_SOURCE, mv->source);
    93         if (!DosQueryPathInfo(mv->source, FIL_STANDARD, &fs1, sizeof(fs1))) {
     94        if (!DosQueryPathInfo(mv->source, FIL_STANDARDL, &fs1, sizeof(fs1))) {
    9495          sprintf(s,
    9596                  " %s%lu %ss %04u/%02u/%02u %02u:%02u:%02u",
     
    118119            strcpy(chkname, mv->target);
    119120        }
    120         if (!DosQueryPathInfo(chkname, FIL_STANDARD, &fs2, sizeof(fs2))) {
     121        if (!DosQueryPathInfo(chkname, FIL_STANDARDL, &fs2, sizeof(fs2))) {
    121122          sprintf(s,
    122123                  " %s%lu %ss %04u/%02u/%02u %02u:%02u:%02u",
  • TabularUnified trunk/dll/saveclip.c

    r838 r841  
    2323#define INCL_DOS
    2424#define INCL_WIN
     25#define INCL_LONGLONG
    2526#include <os2.h>
    2627
     
    432433            fseek(fp, 0, SEEK_SET);
    433434            if (WinQueryButtonCheckstate(hwnd, SAV_APPEND) == 0)
    434               DosSetFileSize((HFILE) fileno(fp), 0);
     435              DosSetFileSizeL((HFILE) fileno(fp), 0);
    435436            else
    436437              fseek(fp, 0, SEEK_END);
     
    711712        INT x = 0;
    712713        SHORT sSelect;
    713         FILEFINDBUF4 ffb4;
     714        FILEFINDBUF4L ffb4;
    714715        ULONG nm;
    715716        HDIR hdir;
     
    781782            fseek(fp, 0, SEEK_SET);
    782783            if (WinQueryButtonCheckstate(hwnd, SAV_APPEND) == 0)
    783               DosSetFileSize((HFILE) fileno(fp), 0);
     784              DosSetFileSizeL((HFILE) fileno(fp), 0);
    784785            else
    785786              fseek(fp, 0, SEEK_END);
     
    792793                                 FILE_READONLY | FILE_ARCHIVED |
    793794                                 FILE_HIDDEN | FILE_SYSTEM,
    794                                  &ffb4, sizeof(ffb4), &nm, FIL_QUERYEASIZE)) {
     795                                 &ffb4, sizeof(ffb4), &nm, FIL_QUERYEASIZEL)) {
    795796                /* load the object's Subject, if required */
    796797                if (ffb4.cbList > 4) {
  • TabularUnified trunk/dll/seeall.c

    r838 r841  
    6060  FDATE date;
    6161  FTIME time;
    62   ULONG cbFile, CRC;
     62  ULONGLONG cbFile;
     63  ULONG CRC;
    6364}
    6465ALLFILES;
     
    463464          x = 0;
    464465          while (list[x]) {
    465             FILESTATUS3 fsa;
     466            FILESTATUS3L fsa;
    466467            // BOOL spaces;
    467468            // if (needs_quoting(list[x])) {
     
    474475            memset(&fsa, 0, sizeof(fsa));
    475476            DosError(FERR_DISABLEHARDERR);
    476             DosQueryPathInfo(list[x], FIL_STANDARD, &fsa, sizeof(fsa));
     477            DosQueryPathInfo(list[x], FIL_STANDARDL, &fsa, sizeof(fsa));
    477478            if (fsa.attrFile & FILE_DIRECTORY) {
    478479              BldQuotedFullPathName(szBuffer + strlen(szBuffer),
     
    564565          APIRET rc;
    565566          INT type;
    566           FILESTATUS4 fs4;
     567          FILESTATUS4L fs4;
    567568          BOOL isnewer, existed;
    568569
     
    706707                  !(driveflags[toupper(*newname) - 'A'] & DRIVE_NOTWRITEABLE)
    707708                  && toupper(*newname) != toupper(*list[x])
    708                   && !DosQueryPathInfo(list[x], FIL_QUERYEASIZE, &fs4,
     709                  && !DosQueryPathInfo(list[x], FIL_QUERYEASIZEL, &fs4,
    709710                                       sizeof(fs4))
    710711                  && !(fs4.attrFile & FILE_DIRECTORY)) {
     
    728729                      DosError(FERR_DISABLEHARDERR);
    729730                      if (!DosQueryPathInfo(list[cntr],
    730                                             FIL_QUERYEASIZE,
     731                                            FIL_QUERYEASIZEL,
    731732                                            &fs4, sizeof(fs4)) &&
    732733                          !(fs4.attrFile & FILE_DIRECTORY) &&
     
    886887          CHECKLIST cl;
    887888          INT isdir = 0, sysdir = 0, ro = 0, hs = 0;
    888           FILESTATUS3 fsa;
     889          FILESTATUS3L fsa;
    889890          CHAR prompt[CCHMAXPATH * 3];
    890891          APIRET error;
     
    899900            }
    900901            DosError(FERR_DISABLEHARDERR);
    901             if (DosQueryPathInfo(list[x], FIL_STANDARD, &fsa, sizeof(fsa))) {
     902            if (DosQueryPathInfo(list[x], FIL_STANDARDL, &fsa, sizeof(fsa))) {
    902903              list = RemoveFromList(list, list[x]);
    903904              if (!list)
     
    981982            fsa.attrFile = 0;
    982983            DosError(FERR_DISABLEHARDERR);
    983             DosQueryPathInfo(list[x], FIL_STANDARD, &fsa, sizeof(fsa));
     984            DosQueryPathInfo(list[x], FIL_STANDARDL, &fsa, sizeof(fsa));
    984985            if (fsa.attrFile & FILE_DIRECTORY) {
    985986              sprintf(prompt, GetPString(IDS_DELETINGTEXT), list[x]);
     
    14141415  ULONG x, z;
    14151416  BOOL ret, didone = FALSE;
    1416   FILEFINDBUF3 ffb;
     1417  FILEFINDBUF3L ffb;
    14171418  ULONG ulFindCnt;
    14181419  HDIR hdir;
     
    14351436                           FILE_DIRECTORY | FILE_READONLY | FILE_SYSTEM |
    14361437                           FILE_HIDDEN, &ffb, sizeof(ffb), &ulFindCnt,
    1437                            FIL_STANDARD)) {
     1438                           FIL_STANDARDL)) {
    14381439          DosFindClose(hdir);
    14391440          if (!(ffb.attrFile & FILE_DIRECTORY)) {
     
    14561457                           FILE_DIRECTORY | FILE_READONLY | FILE_SYSTEM |
    14571458                           FILE_HIDDEN, &ffb, sizeof(ffb), &ulFindCnt,
    1458                            FIL_STANDARD)) {
     1459                           FIL_STANDARDL)) {
    14591460          DosFindClose(hdir);
    14601461          if (!(ffb.attrFile & FILE_DIRECTORY)) {
     
    18881889  ALLDATA *ad = WinQueryWindowPtr(hwnd, QWL_USER);
    18891890  CHAR *filename, *enddir;
    1890   PFILEFINDBUF3 pffbArray, pffbFile;
     1891  PFILEFINDBUF3L pffbArray, pffbFile;
    18911892  HDIR hdir = HDIR_CREATE;
    18921893  ULONG ulFindCnt;
     
    19061907    ulFindMax = 1;
    19071908
    1908   ulBufBytes = sizeof(FILEFINDBUF3) * ulFindMax;
     1909  ulBufBytes = sizeof(FILEFINDBUF3L) * ulFindMax;
    19091910  pffbArray = xmalloc(ulBufBytes, pszSrcFile, __LINE__);
    19101911  if (!pffbArray) {
     
    19261927                     FILE_READONLY | FILE_DIRECTORY | FILE_SYSTEM |
    19271928                     FILE_HIDDEN,
    1928                      pffbArray, ulBufBytes, &ulFindCnt, FIL_STANDARD);
     1929                     pffbArray, ulBufBytes, &ulFindCnt, FIL_STANDARDL);
    19291930  if (!rc) {
    19301931    do {
     
    19911992          }
    19921993        }
    1993         pffbFile = (PFILEFINDBUF3)((PBYTE)pffbFile + pffbFile->oNextEntryOffset);
     1994        pffbFile = (PFILEFINDBUF3L)((PBYTE)pffbFile + pffbFile->oNextEntryOffset);
    19941995      } // for
    19951996      if (ad->stopflag)
    19961997        break;
    19971998      ulFindCnt = ulFindMax;
    1998       rc = xDosFindNext(hdir, pffbArray, sizeof(FILEFINDBUF3) * ulFindCnt, &ulFindCnt);
     1999      rc = xDosFindNext(hdir, pffbArray, sizeof(FILEFINDBUF3L) * ulFindCnt, &ulFindCnt);
    19992000    } while (!rc);
    20002001    DosFindClose(hdir);
  • TabularUnified trunk/dll/select.c

    r814 r841  
    815815          }
    816816          else {
    817             size_t len1 = filelength(fileno(fp1));
    818             size_t len2 = filelength(fileno(fp2));
     817            size_t len1 = _filelengthi64(fileno(fp1));
     818            size_t len2 = _filelengthi64(fileno(fp2));
    819819
    820820            if (len1 == len2) {
  • TabularUnified trunk/dll/shadow.c

    r793 r841  
    1818#define INCL_DOS
    1919#define INCL_WIN
     20#define INCL_LONGLONG
    2021#include <os2.h>
    2122
     
    166167  CHAR szBuff[CCHMAXPATH + 8];
    167168  HOBJECT obj = (HOBJECT) 0;
    168   FILESTATUS3 fsa;
     169  FILESTATUS3L fsa;
    169170
    170171  *szBuff = 0;
     
    199200    while (list[x]) {
    200201      if (!DosQueryPathInfo(list[x],
    201                             FIL_STANDARD, &fsa,
    202                             (ULONG) sizeof(FILESTATUS3))) {
     202                            FIL_STANDARDL, &fsa,
     203                            (ULONG) sizeof(FILESTATUS3L))) {
    203204
    204205        ULONG apt;
  • TabularUnified trunk/dll/srchpath.c

    r809 r841  
    1818#define INCL_DOS
    1919#define INCL_DOSERRORS
     20#define INCL_LONGLONG
    2021
    2122#include <os2.h>
     
    104105      || strchr(filename, ':')) {
    105106
    106     FILESTATUS3 fsa;
     107    FILESTATUS3L fsa;
    107108
    108     if (!DosQueryPathInfo(filename, FIL_STANDARD, &fsa, (ULONG) sizeof(fsa)))
     109    if (!DosQueryPathInfo(filename, FIL_STANDARDL, &fsa, (ULONG) sizeof(fsa)))
    109110      return filename;
    110111    *fbuf = 0;
  • TabularUnified trunk/dll/subj.c

    r827 r841  
    2020#define INCL_DOS
    2121#define INCL_DOSERRORS
     22#define INCL_LONGLONG
    2223#include <os2.h>
    2324
  • TabularUnified trunk/dll/tools.c

    r838 r841  
    2222#define INCL_DOS
    2323#define INCL_WIN
     24#define INCL_LONGLONG
    2425#include <os2.h>
    2526
     
    889890                      EM_SETTEXTLIMIT, MPFROM2SHORT(CCHMAXPATH, 0), MPVOID);
    890891    {
    891       FILEFINDBUF3 findbuf;
     892      FILEFINDBUF3L findbuf;
    892893      HDIR hDir;
    893894      ULONG ulSearchCount, x = 0;
     
    904905                           FILE_ARCHIVED,
    905906                           &findbuf,
    906                            sizeof(FILEFINDBUF3),
    907                            &ulSearchCount, FIL_STANDARD)) {
     907                           sizeof(FILEFINDBUF3L),
     908                           &ulSearchCount, FIL_STANDARDL)) {
    908909          do {
    909910            priority_bumped();
     
    916917          } while (!xDosFindNext(hDir,
    917918                                 &findbuf,
    918                                  sizeof(FILEFINDBUF3), &ulSearchCount));
     919                                 sizeof(FILEFINDBUF3L), &ulSearchCount));
    919920          DosFindClose(hDir);
    920921          priority_bumped();
  • TabularUnified trunk/dll/treecnr.c

    r838 r841  
    961961    if (dcd && dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent) &&
    962962        hwndStatus2) {
    963       FILEFINDBUF3 ffb;
     963      FILEFINDBUF3L ffb;
    964964      ULONG nm = 1;
    965965      HDIR hdir = HDIR_CREATE;
     
    970970                           FILE_NORMAL | FILE_HIDDEN |
    971971                           FILE_SYSTEM | FILE_ARCHIVED | FILE_READONLY,
    972                            &ffb, sizeof(ffb), &nm, FIL_STANDARD)) {
     972                           &ffb, sizeof(ffb), &nm, FIL_STANDARDL)) {
    973973          CHAR tb[39], tm[39], tpm[39], s[163];
    974974          ULONG amem;
     
    17281728  case UM_ENTER:
    17291729    {
    1730       FILEFINDBUF3 ffb;
     1730      FILEFINDBUF3L ffb;
    17311731      HDIR hDir = HDIR_CREATE;
    17321732      ULONG nm = 1;
     
    18921892                                 FILE_ARCHIVED | FILE_READONLY |
    18931893                                 FILE_HIDDEN | FILE_SYSTEM,
    1894                                  &ffb, sizeof(ffb), &nm, FIL_STANDARD);
     1894                                 &ffb, sizeof(ffb), &nm, FIL_STANDARDL);
    18951895          priority_bumped();
    18961896        }
  • TabularUnified trunk/dll/undel.c

    r793 r841  
    2020#define INCL_DOS
    2121#define INCL_WIN
     22#define INCL_LONGLONG
    2223#include <os2.h>
    2324
     
    5556  struct tempstruct *undelinfo;
    5657  BOOL killme = FALSE;
    57   FILESTATUS3 fsa;
     58  FILESTATUS3L fsa;
    5859
    5960  undelinfo = (struct tempstruct *)arg;
     
    135136                                     MPFROM2SHORT(0, LIT_FIRST),
    136137                                     MPFROMP(s)) < 0
    137                    && DosQueryPathInfo(s, FIL_STANDARD, &fsa,
     138                   && DosQueryPathInfo(s, FIL_STANDARDL, &fsa,
    138139                                       (ULONG) sizeof(fsa)))
    139140            WinSendDlgItemMsg(hwnd, UNDEL_LISTBOX, LM_INSERTITEM,
  • TabularUnified trunk/dll/update.c

    r838 r841  
    6262{
    6363  PCNRITEM pci;
    64   FILEFINDBUF4 ffb;
     64  FILEFINDBUF4L ffb;
    6565  HDIR hDir = HDIR_CREATE;
    6666  ULONG nm = 1;
     
    8585                         FILE_ARCHIVED | FILE_READONLY |
    8686                         FILE_HIDDEN | FILE_SYSTEM,
    87                          &ffb, sizeof(ffb), &nm, FIL_QUERYEASIZE);
     87                         &ffb, sizeof(ffb), &nm, FIL_QUERYEASIZEL);
    8888  if (!status) {
    8989#ifdef DEBUG
     
    335335{
    336336  PCNRITEM pci, *pciList = NULL;
    337   FILEFINDBUF4 ffb;
     337  FILEFINDBUF4L ffb;
    338338  HDIR hDir;
    339339  ULONG nm = (ULONG) howmany;
     
    376376                             FILE_ARCHIVED | FILE_READONLY |
    377377                             FILE_HIDDEN | FILE_SYSTEM,
    378                              &ffb, sizeof(ffb), &nm, FIL_QUERYEASIZE);
     378                             &ffb, sizeof(ffb), &nm, FIL_QUERYEASIZEL);
    379379      if (!status) {
    380380        /* file exists */
  • TabularUnified trunk/dll/valid.c

    r793 r841  
    3131#define INCL_DOSDEVICES                 // DosDevIOCtl
    3232#define INCL_DOSDEVIOCTL                // DosDevIOCtl
     33#define INCL_LONGLONG
    3334#include <os2.h>
    3435
     
    8687
    8788  int comp = 0;
    88   FILESTATUS3 fs3o, fs3n;
     89  FILESTATUS3L fs3o, fs3n;
    8990
    9091  DosError(FERR_DISABLEHARDERR);
    91   if (!DosQueryPathInfo(file1, FIL_STANDARD, &fs3o, sizeof(fs3o))) {
    92     DosError(FERR_DISABLEHARDERR);
    93     if (!DosQueryPathInfo(file2, FIL_STANDARD, &fs3n, sizeof(fs3n))) {
     92  if (!DosQueryPathInfo(file1, FIL_STANDARDL, &fs3o, sizeof(fs3o))) {
     93    DosError(FERR_DISABLEHARDERR);
     94    if (!DosQueryPathInfo(file2, FIL_STANDARDL, &fs3n, sizeof(fs3n))) {
    9495      comp = (fs3n.fdateLastWrite.year >
    9596              fs3o.fdateLastWrite.year) ? 1 :
     
    299300
    300301  DosError(FERR_DISABLEHARDERR);
    301   rc = DosOpen(szPath, &hDev, &ulAction, 0, 0, FILE_OPEN,
    302                OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE |
    303                OPEN_FLAGS_DASD | OPEN_FLAGS_FAIL_ON_ERROR, 0);
     302  rc = DosOpenL(szPath, &hDev, &ulAction, 0, 0, FILE_OPEN,
     303                OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE |
     304                OPEN_FLAGS_DASD | OPEN_FLAGS_FAIL_ON_ERROR, 0);
    304305  if (rc) {
    305306    DosError(FERR_DISABLEHARDERR);
     
    352353  /* returns:  -1 (error), 0 (is a directory), or 1 (is a file) */
    353354
    354   FILESTATUS3 fsa1, fsa2;
     355  FILESTATUS3L fsa1, fsa2;
    355356  APIRET ret;
    356357
    357358  if (filename1 && filename2) {
    358359    DosError(FERR_DISABLEHARDERR);
    359     ret = DosQueryPathInfo(filename1, FIL_STANDARD, &fsa1,
     360    ret = DosQueryPathInfo(filename1, FIL_STANDARDL, &fsa1,
    360361                           (ULONG) sizeof(fsa1));
    361362    if (!ret) {
    362363      DosError(FERR_DISABLEHARDERR);
    363       ret = DosQueryPathInfo(filename2, FIL_STANDARD, &fsa2,
     364      ret = DosQueryPathInfo(filename2, FIL_STANDARDL, &fsa2,
    364365                             (ULONG) sizeof(fsa2));
    365366      if (!ret) {
     
    378379  /* returns:  -1 (error), 0 (is a directory), or 1 (is a file) */
    379380
    380   FILESTATUS3 fsa;
     381  FILESTATUS3L fsa;
    381382  APIRET ret;
    382383
    383384  if (filename && *filename) {
    384385    DosError(FERR_DISABLEHARDERR);
    385     ret = DosQueryPathInfo(filename, FIL_STANDARD, &fsa, (ULONG) sizeof(fsa));
     386    ret = DosQueryPathInfo(filename, FIL_STANDARDL, &fsa, (ULONG) sizeof(fsa));
    386387    if (!ret)
    387388      return ((fsa.attrFile & FILE_DIRECTORY) == 0);
     
    407408{
    408409  CHAR fullname[CCHMAXPATH];
    409   FILESTATUS3 fs;
     410  FILESTATUS3L fs;
    410411
    411412  if (path) {
     
    417418          DosError(FERR_DISABLEHARDERR);
    418419          if (!DosQueryPathInfo(fullname,
    419                                 FIL_STANDARD,
     420                                FIL_STANDARDL,
    420421                                &fs,
    421422                                sizeof(fs)) && (fs.attrFile & FILE_DIRECTORY))
     
    461462  ULONG ulDrv;
    462463  CHAR *p;
    463   FILESTATUS3 fs;
     464  FILESTATUS3L fs;
    464465  APIRET rc;
    465466
     
    471472          return path;
    472473        DosError(FERR_DISABLEHARDERR);
    473         rc = DosQueryPathInfo(path, FIL_STANDARD, &fs, sizeof(fs));
     474        rc = DosQueryPathInfo(path, FIL_STANDARDL, &fs, sizeof(fs));
    474475        if (!rc && (fs.attrFile & FILE_DIRECTORY))
    475476          return path;
     
    866867
    867868  if (filename) {
    868     if (!DosOpen(filename, &handle, &ulAction, 0, 0,
    869                  OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
    870                  OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
    871                  OPEN_FLAGS_SEQUENTIAL | OPEN_SHARE_DENYNONE |
    872                  OPEN_ACCESS_READONLY, 0)) {
     869    if (!DosOpenL(filename, &handle, &ulAction, 0, 0,
     870                  OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
     871                  OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
     872                  OPEN_FLAGS_SEQUENTIAL | OPEN_SHARE_DENYNONE |
     873                  OPEN_ACCESS_READONLY, 0)) {
    873874      len = 512;
    874875      rc = DosRead(handle, buff, len, &len);
  • TabularUnified trunk/dll/viewer.c

    r793 r841  
    1919#define INCL_DOS
    2020#define INCL_WIN
     21#define INCL_LONGLONG
    2122#include <os2.h>
    2223
     
    790791      if (!MLEgetreadonly(hwndMLE)) {
    791792
    792         LONG oldsize;
     793        LONGLONG oldsize;
    793794
    794795        if (!*vw->exportfilename ||
     
    808809          fp = xfopen(vw->exportfilename, "r+", pszSrcFile, __LINE__);
    809810          if (fp) {
    810             oldsize = filelength(fileno(fp));
    811             DosSetFileSize(fileno(fp), 0);
     811            oldsize = _filelengthi64(fileno(fp));
     812            DosSetFileSizeL(fileno(fp), 0);
    812813            fclose(fp);
    813814          }
     
    822823          fp = xfopen(vw->exportfilename, "r+", pszSrcFile, __LINE__);
    823824          if (fp) {
    824             DosSetFileSize(fileno(fp), oldsize);
     825            DosSetFileSizeL(fileno(fp), oldsize);
    825826            fclose(fp);
    826827          }
  • TabularUnified trunk/dll/viewinf.c

    r838 r841  
    2121#define INCL_DOS
    2222#define INCL_WIN
     23#define INCL_LONGLONG
    2324#include <os2.h>
    2425
     
    9394
    9495              CHAR mask[CCHMAXPATH], *enddir, text[CCHMAXPATH * 2];
    95               FILEFINDBUF3 ffb;
     96              FILEFINDBUF3L ffb;
    9697              HDIR hdir;
    9798              ULONG nm;
     
    109110              DosError(FERR_DISABLEHARDERR);
    110111              if (!xDosFindFirst(mask, &hdir, FILE_NORMAL | FILE_ARCHIVED,
    111                                  &ffb, sizeof(ffb), &nm, FIL_STANDARD)) {
     112                                 &ffb, sizeof(ffb), &nm, FIL_STANDARDL)) {
    112113                do {
    113114                  priority_normal();
  • TabularUnified trunk/dll/walkem.c

    r838 r841  
    2929#define INCL_DOSERRORS
    3030#define INCL_SHLERRORS                  // PMERR_NOT_IN_IDX
     31#define INCL_LONGLONG
    3132#include <os2.h>
    3233
     
    538539
    539540  CHAR szDrive[] = " :", szTemp[1032];
    540   FILEFINDBUF3 findbuf;
     541  FILEFINDBUF3L findbuf;
    541542  HDIR hDir = HDIR_CREATE;
    542543  SHORT sDrive;
     
    580581                       FILE_HIDDEN,
    581582                       &findbuf,
    582                        sizeof(FILEFINDBUF3), &ulSearchCount, FIL_STANDARD)) {
     583                       sizeof(FILEFINDBUF3L), &ulSearchCount, FIL_STANDARDL)) {
    583584      do {
    584585        if (findbuf.attrFile & FILE_DIRECTORY) {
     
    597598        ulSearchCount = 1;
    598599      } while (!xDosFindNext(hDir,
    599                              &findbuf, sizeof(FILEFINDBUF3), &ulSearchCount));
     600                             &findbuf, sizeof(FILEFINDBUF3L), &ulSearchCount));
    600601      DosFindClose(hDir);
    601602    }
     
    695696      ULONG ulDriveNum, ulDriveMap;
    696697      ULONG ulSearchCount;
    697       FILEFINDBUF3 findbuf;
     698      FILEFINDBUF3L findbuf;
    698699      HDIR hDir;
    699700      APIRET rc;
     
    714715                               MUST_HAVE_DIRECTORY | FILE_READONLY |
    715716                               FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
    716                                &findbuf, sizeof(FILEFINDBUF3),
    717                                &ulSearchCount, FIL_STANDARD);
     717                               &findbuf, sizeof(FILEFINDBUF3L),
     718                               &ulSearchCount, FIL_STANDARDL);
    718719          else {
    719720            rc = 0;
     
    755756                               MUST_HAVE_DIRECTORY | FILE_READONLY |
    756757                               FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
    757                                &findbuf, sizeof(FILEFINDBUF3),
    758                                &ulSearchCount, FIL_STANDARD);
     758                               &findbuf, sizeof(FILEFINDBUF3L),
     759                               &ulSearchCount, FIL_STANDARDL);
    759760          else {
    760761            rc = 0;
     
    891892
    892893        ULONG ulSearchCount;
    893         FILEFINDBUF3 findbuf;
     894        FILEFINDBUF3L findbuf;
    894895        HDIR hDir;
    895896        APIRET rc;
     
    906907                             MUST_HAVE_DIRECTORY | FILE_READONLY |
    907908                             FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
    908                              &findbuf, sizeof(FILEFINDBUF3),
    909                              &ulSearchCount, FIL_STANDARD);
     909                             &findbuf, sizeof(FILEFINDBUF3L),
     910                             &ulSearchCount, FIL_STANDARDL);
    910911          if (!rc)
    911912            DosFindClose(hDir);
     
    941942
    942943        ULONG ulSearchCount;
    943         FILEFINDBUF3 findbuf;
     944        FILEFINDBUF3L findbuf;
    944945        HDIR hDir;
    945946        APIRET rc;
     
    955956                             FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
    956957                             &findbuf,
    957                              sizeof(FILEFINDBUF3),
    958                              &ulSearchCount, FIL_STANDARD);
     958                             sizeof(FILEFINDBUF3L),
     959                             &ulSearchCount, FIL_STANDARDL);
    959960          if (!rc)
    960961            DosFindClose(hDir);
     
    10171018
    10181019        ULONG ulSearchCount;
    1019         FILEFINDBUF3 findbuf;
     1020        FILEFINDBUF3L findbuf;
    10201021        HDIR hDir;
    10211022        APIRET rc;
     
    10381039                               FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
    10391040                               &findbuf,
    1040                                sizeof(FILEFINDBUF3),
    1041                                &ulSearchCount, FIL_STANDARD);
     1041                               sizeof(FILEFINDBUF3L),
     1042                               &ulSearchCount, FIL_STANDARDL);
    10421043            if (!rc)
    10431044              DosFindClose(hDir);
     
    13801381
    13811382        ULONG ulSearchCount;
    1382         FILEFINDBUF3 findbuf;
     1383        FILEFINDBUF3L findbuf;
    13831384        HDIR hDir;
    13841385        APIRET rc;
     
    14011402                               FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
    14021403                               &findbuf,
    1403                                sizeof(FILEFINDBUF3),
    1404                                &ulSearchCount, FIL_STANDARD);
     1404                               sizeof(FILEFINDBUF3L),
     1405                               &ulSearchCount, FIL_STANDARDL);
    14051406            if (!rc)
    14061407              DosFindClose(hDir);
     
    14451446
    14461447        ULONG ulSearchCount;
    1447         FILEFINDBUF3 findbuf;
     1448        FILEFINDBUF3L findbuf;
    14481449        HDIR hDir;
    14491450        APIRET rc;
     
    14661467                               FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
    14671468                               &findbuf,
    1468                                sizeof(FILEFINDBUF3),
    1469                                &ulSearchCount, FIL_STANDARD);
     1469                               sizeof(FILEFINDBUF3L),
     1470                               &ulSearchCount, FIL_STANDARDL);
    14701471            if (!rc)
    14711472              DosFindClose(hDir);
  • TabularUnified trunk/dll/worker.c

    r809 r841  
    3131#define INCL_DOSERRORS
    3232#define INCL_WPCLASS                    // WinQueryObjectPath
     33#define INCL_LONGLONG
    3334#include <os2.h>
    3435
     
    127128        if (hmq2) {
    128129          CHAR message[(CCHMAXPATH * 2) + 80], wildname[CCHMAXPATH];
    129           register INT x;
     130          INT x;
    130131          BOOL dontask = FALSE, wildcarding = FALSE, overold =
    131132            FALSE, overnew = FALSE, usedtarget;
     
    397398                    goto Abort;
    398399                  {
    399                     FILESTATUS3 fsa;
     400                    FILESTATUS3L fsa;
    400401
    401402                    DosError(FERR_DISABLEHARDERR);
    402403                    if (DosQueryPathInfo(ex.extractdir,
    403                                          FIL_STANDARD,
     404                                         FIL_STANDARDL,
    404405                                         &fsa,
    405                                          (ULONG) sizeof(FILESTATUS3)) ||
    406                         !(fsa.attrFile & FILE_DIRECTORY))
     406                                         (ULONG) sizeof(FILESTATUS3L)) ||
     407                    !(fsa.attrFile & FILE_DIRECTORY))
    407408                      goto Abort;
    408409                  }
     
    486487              case IDM_OPENTREE:
    487488                {
    488                   FILESTATUS3 fsa;
     489                  FILESTATUS3L fsa;
    489490
    490491                  DosError(FERR_DISABLEHARDERR);
    491492                  if (DosQueryPathInfo(wk->li->list[x],
    492                                        FIL_STANDARD,
     493                                       FIL_STANDARDL,
    493494                                       &fsa,
    494                                        (ULONG) sizeof(FILESTATUS3)) ||
    495                       !(fsa.attrFile & FILE_DIRECTORY))
     495                                       (ULONG) sizeof(FILESTATUS3L)) ||
     496                  !(fsa.attrFile & FILE_DIRECTORY))
    496497                    break;
    497498                }
     
    600601                  APIRET rc;
    601602                  INT type;
    602                   FILESTATUS4 fs4;
     603                  FILESTATUS4L fs4;
    603604                  BOOL isnewer, existed;
    604605
     
    755756                             DRIVE_NOTWRITEABLE)
    756757                        && toupper(*newname) != toupper(*wk->li->list[x])
    757                         && !DosQueryPathInfo(wk->li->list[x], FIL_QUERYEASIZE,
     758                        && !DosQueryPathInfo(wk->li->list[x], FIL_QUERYEASIZEL,
    758759                                             &fs4, sizeof(fs4))
    759760                        && !(fs4.attrFile & FILE_DIRECTORY)) {
     
    777778                            DosError(FERR_DISABLEHARDERR);
    778779                            if (!DosQueryPathInfo(wk->li->list[cntr],
    779                                                   FIL_QUERYEASIZE,
     780                                                  FIL_QUERYEASIZEL,
    780781                                                  &fs4,
    781782                                                  sizeof(fs4)) &&
     
    12471248              x = 0;
    12481249              while (wk->li->list[x]) {
    1249                 FILESTATUS3 fsa;
     1250                FILESTATUS3L fsa;
    12501251                // BOOL spaces;
    12511252                // if (needs_quoting(wk->li->list[x])) {
     
    12561257                //   spaces = FALSE;
    12571258                // strcat(szBuffer, wk->li->list[x]);
    1258                 memset(&fsa, 0, sizeof(FILESTATUS3));
     1259                memset(&fsa, 0, sizeof(FILESTATUS3L));
    12591260                DosError(FERR_DISABLEHARDERR);
    12601261                DosQueryPathInfo(wk->li->list[x],
    1261                                  FIL_STANDARD,
    1262                                  &fsa, (ULONG) sizeof(FILESTATUS3));
     1262                                 FIL_STANDARDL,
     1263                                 &fsa, (ULONG) sizeof(FILESTATUS3L));
    12631264                if (fsa.attrFile & FILE_DIRECTORY) {
    12641265                  BldQuotedFullPathName(szBuffer + strlen(szBuffer), wk->li->list[x], "*");
     
    14471448              INT isdir = 0, sysdir = 0, ro = 0, hs = 0;
    14481449              register INT x;
    1449               FILESTATUS3 fsa;
     1450              FILESTATUS3L fsa;
    14501451              CHAR prompt[CCHMAXPATH * 3];
    14511452              APIRET error;
     
    14621463                DosError(FERR_DISABLEHARDERR);
    14631464                if (DosQueryPathInfo(wk->li->list[x],
    1464                                      FIL_STANDARD, &fsa,
    1465                                      (ULONG) sizeof(FILESTATUS3))) {
     1465                                     FIL_STANDARDL, &fsa,
     1466                                     (ULONG) sizeof(FILESTATUS3L))) {
    14661467                  wk->li->list = RemoveFromList(wk->li->list,
    14671468                                                wk->li->list[x]);
     
    15491550                DosError(FERR_DISABLEHARDERR);
    15501551                DosQueryPathInfo(wk->li->list[x],
    1551                                  FIL_STANDARD,
    1552                                  &fsa, (ULONG) sizeof(FILESTATUS3));
     1552                                 FIL_STANDARDL,
     1553                                 &fsa, (ULONG) sizeof(FILESTATUS3L));
    15531554                if (fsa.attrFile & FILE_DIRECTORY) {
    15541555                  sprintf(prompt,
  • TabularUnified trunk/dll/wrappers.c

    r838 r841  
    1919#define INCL_DOS
    2020#define INCL_DOSERRORS
     21#define INCL_LONGLONG
    2122#include <os2.h>
    2223
     
    3031static PSZ pszSrcFile = __FILE__;
    3132
    32 APIRET APIENTRY  xDosFindFirst(PSZ    pszFileSpec,
    33                                PHDIR  phdir,
    34                                ULONG  flAttribute,
    35                                PVOID  pfindbuf,
    36                                ULONG  cbBuf,
    37                                PULONG pcFileNames,
    38                                ULONG  ulInfoLevel)
     33APIRET xDosFindFirst(PSZ    pszFileSpec,
     34                     PHDIR  phdir,
     35                     ULONG  flAttribute,
     36                     PVOID  pfindbuf,
     37                     ULONG  cbBuf,
     38                     PULONG pcFileNames,
     39                     ULONG  ulInfoLevel)
    3940{
    4041    APIRET rc;
     
    4546}
    4647
    47 APIRET APIENTRY  xDosFindNext(HDIR   hDir,
    48                               PVOID  pfindbuf,
    49                               ULONG  cbfindbuf,
    50                               PULONG pcFilenames)
     48APIRET xDosFindNext(HDIR   hDir,
     49                    PVOID  pfindbuf,
     50                    ULONG  cbfindbuf,
     51                    PULONG pcFilenames)
    5152{
    5253  APIRET rc;
     
    6566 * and we don't put enough additional data on the stack for this to occur.
    6667 * It is caller's responsitibility to report errors
    67  * @param pInfoBuf pointer to FILESTATUS3 or EAOP2 buffer
    68  * @param ulInfoLevel FIL_STANDARD or FIL_QUERYEASIZE
     68 * @param pInfoBuf pointer to FILESTATUS3L or EAOP2 buffer
     69 * @param ulInfoLevel FIL_STANDARDL or FIL_QUERYEASIZE
    6970 * @returns Same as DosSetPathInfo
    7071 */
    7172
    72 APIRET APIENTRY xDosSetPathInfo(PSZ pszPathName,
    73                                 ULONG ulInfoLevel,
    74                                 PVOID pInfoBuf,
    75                                 ULONG cbInfoBuf,
    76                                 ULONG flOptions)
     73APIRET xDosSetPathInfo(PSZ pszPathName,
     74                       ULONG ulInfoLevel,
     75                       PVOID pInfoBuf,
     76                       ULONG cbInfoBuf,
     77                       ULONG flOptions)
    7778{
    7879    APIRET rc = DosSetPathInfo(pszPathName, ulInfoLevel, pInfoBuf, cbInfoBuf, flOptions);
    79     FILESTATUS3 alt_fs3;
     80    FILESTATUS3L alt_fs3;
    8081    EAOP2 alt_eaop2;
    8182    if (rc == ERROR_INVALID_NAME) {
    8283      switch (ulInfoLevel) {
    83       case FIL_STANDARD:
    84         alt_fs3 = *(PFILESTATUS3)pInfoBuf;      // Copy
     84      case FIL_STANDARDL:
     85        alt_fs3 = *(PFILESTATUS3L)pInfoBuf;     // Copy
    8586        rc = DosSetPathInfo(pszPathName, ulInfoLevel, &alt_fs3, sizeof(alt_fs3), flOptions);
    8687        break;
     
    207208
    208209#pragma alloc_text(WRAPPERS1,xfree,xfopen,xfsopen,xmalloc,xrealloc, xstrdup)
    209 
     210#pragma alloc_text(WRAPPERS2,xDosSetPathInfo,xDosFindFirst,xDosFindNext)
  • TabularUnified trunk/undel.c

    r551 r841  
    11#define INCL_DOS
    22#define INCL_WIN
     3#define INCL_LONGLONG
    34
    45#include <os2.h>
     
    1617  HAB hab;
    1718  HMQ hmq;
    18   FILESTATUS3 fs;
     19  FILESTATUS3L fs;
    1920  static CHAR fullname[CCHMAXPATH];
    2021  CHAR *thisarg = NULL;
     
    3334  }
    3435  DosError(FERR_DISABLEHARDERR);
    35   if (thisarg && !DosQueryPathInfo(thisarg, FIL_STANDARD, &fs, sizeof(fs))) {
     36  if (thisarg && !DosQueryPathInfo(thisarg, FIL_STANDARDL, &fs, sizeof(fs))) {
    3637    if (DosQueryPathInfo(thisarg,
    3738                         FIL_QUERYFULLNAME, fullname, sizeof(fullname)))
Note: See TracChangeset for help on using the changeset viewer.