Changeset 766


Ignore:
Timestamp:
Aug 5, 2007, 8:21:20 PM (13 years ago)
Author:
Gregg Young
Message:

format cleanup

Location:
trunk
Files:
25 edited

Legend:

Unmodified
Added
Removed
  • trunk/dll/arccnrs.c

    r762 r766  
    19801980              WinSendMsg(dcd->hwndCnr, WM_COMMAND,
    19811981                         MPFROM2SHORT(IDM_COLLECTOR, 0), MPVOID);
    1982               DosSleep(128L);
     1982              DosSleep(128);
    19831983              if (Collector) {
    19841984                if (!PostMsg(Collector, WM_COMMAND,
     
    20052005    if (dcd) {
    20062006      if (*dcd->workdir) {
    2007         DosSleep(33L);
     2007        DosSleep(33);
    20082008        wipeallf("%s\\*", dcd->workdir);
    20092009        if (rmdir(dcd->workdir)) {
    2010           DosSleep(256L);
     2010          DosSleep(256);
    20112011          wipeallf("%s\\*", dcd->workdir);
    20122012          rmdir(dcd->workdir);
     
    23962396        }
    23972397        else
    2398           DosSleep(1L);
     2398          DosSleep(1);
    23992399        SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
    24002400                                  DIR_FILTER), &dcd->mask, TRUE);
     
    27932793            }
    27942794            WinSetWindowPos(hwndC, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
    2795             DosSleep(128L);
     2795            DosSleep(128);
    27962796          }
    27972797        }
  • trunk/dll/common.c

    r751 r766  
    563563      ltoa(threaduse, ts, 10);
    564564      WinSetWindowText(hwndLEDHdr, ts);
    565       DosSleep(0);
     565      DosSleep(1);
    566566    }
    567567    return 0;
  • trunk/dll/dircnrs.c

    r762 r766  
    627627      dcd->hwndObject = hwnd;
    628628      if (ParentIsDesktop(hwnd, dcd->hwndParent))
    629         DosSleep(250L);
     629        DosSleep(250);
    630630    }
    631631    else
     
    693693          if (!pciC) {
    694694            Stubby(dcd->hwndCnr, pci);
    695             DosSleep(0L);
     695            DosSleep(1);
    696696          }
    697697        }
     
    14861486        }
    14871487        else
    1488           DosSleep(64L);
     1488          DosSleep(64);
    14891489        WinEnableMenuItem(DirCnrMenu, IDM_FINDINTREE, (hwndTree != (HWND) 0));
    14901490      }
     
    19611961              TileChildren(dcd->hwndParent, TRUE);
    19621962            WinSetWindowPos(hwndC, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
    1963             DosSleep(250L);
     1963            DosSleep(250);
    19641964          }
    19651965        }
     
    19701970
    19711971      case IDM_COLLECTOR:
    1972         DosSleep(64L);
     1972        DosSleep(64);
    19731973        {
    19741974          CHAR **list;
     
    24692469                    WinSetWindowPos(hwndC, HWND_TOP, 0, 0, 0, 0,
    24702470                                    SWP_ACTIVATE);
    2471                     DosSleep(250L);
     2471                    DosSleep(250);
    24722472                  }
    24732473                }
  • trunk/dll/grep.c

    r756 r766  
    258258      WinCancelShutdown(ghmq, TRUE);
    259259      IncrThreadUsage();
    260       DosSleep(128L);
     260      DosSleep(128);
    261261      WinSetWindowText(grep.hwndCurFile,
    262262                       GetPString((grep.finddupes) ?
     
    438438          domatchingfiles(grep, searchPath, fle, numfls);
    439439          doallsubdirs(grep, searchPath, TRUE, fle, numfls);
    440           DosSleep(0L);
    441         }
    442       }
    443       findCount = 1L;
     440          DosSleep(1);
     441        }
     442      }
     443      findCount = 1;
    444444    } while (!DosFindNext(findHandle,
    445445                          &findBuffer,
     
    525525                       (PULONG) & findCount);
    526526      if (!rc)
    527         DosSleep(1L);
     527        DosSleep(1);
    528528    } while (!rc);
    529529    DosFindClose(findHandle);
     
    596596    }
    597597    if (grep->toinsert == grep->FilesToGet)
    598       DosSleep(1L);
     598      DosSleep(1);
    599599    freegreplist(grep);
    600600    PostMsg(grep->hwndFiles, UM_RESCAN, MPVOID, MPVOID);
     
    808808      }                                 // while
    809809      Free_FEAList(head);
    810       DosSleep(1L);
     810      DosSleep(1);
    811811    }
    812812  }
     
    842842      }
    843843      free(input);
    844       DosSleep(1L);
     844      DosSleep(1);
    845845    }
    846846  } // if
     
    954954        else
    955955          break;
    956         DosSleep(0L);
     956        DosSleep(1);
    957957      }
    958958      fclose(fp);
    959       DosSleep(1L);
     959      DosSleep(1);
    960960    }
    961961    free(buffer);
     
    11141114  CHAR **list = NULL;
    11151115  INT numfiles = 0, numalloced = 0, error;
    1116   register ULONG x = 0L, y = 0L;
     1116  register ULONG x = 0, y = 0;
    11171117  ULONG cntr = 100;
    11181118
     
    11261126  if (x) {
    11271127    WinSetWindowText(g->hwndCurFile, GetPString(IDS_GREPDUPESORTINGTEXT));
    1128     DosSleep(1L);
     1128    DosSleep(1);
    11291129    g->dupenames = xmalloc(sizeof(DUPES *) * (x + 1), pszSrcFile, __LINE__);
    11301130    if (!g->nosizedupes)
     
    11421142      if (!g->nosizedupes)
    11431143        g->dupesizes[y] = NULL;
    1144       DosSleep(1L);
     1144      DosSleep(1);
    11451145      qsort(g->dupenames,
    11461146            x,
    11471147            sizeof(DUPES *),
    11481148            ((g->ignoreextdupes) ? comparenamesqe : comparenamesq));
    1149       DosSleep(1L);
     1149      DosSleep(1);
    11501150      if (!g->nosizedupes) {
    11511151        qsort(g->dupesizes, x, sizeof(DUPES *), comparesizesq);
    1152         DosSleep(1L);
     1152        DosSleep(1);
    11531153      }
    11541154      WinSetWindowText(g->hwndCurFile, GetPString(IDS_GREPDUPECOMPARINGTEXT));
    11551155
    11561156      i = g->dupehead;
    1157       y = 0L;
     1157      y = 0;
    11581158      while (i) {
    11591159        if (*g->stopflag)
     
    12861286          sprintf(s, GetPString(IDS_GREPDUPECHECKPROGTEXT), y, g->numfiles);
    12871287          WinSetWindowText(g->hwndCurFile, s);
    1288           DosSleep(128L);
     1288          DosSleep(128);
    12891289        }
    12901290        DosSleep(y % 2);
     
    12951295      DosBeep(50, 100);
    12961296      WinSetWindowText(g->hwndCurFile, GetPString(IDS_GREPDUPECOMPARINGTEXT));
    1297       x = y = 0L;
     1297      x = y = 0;
    12981298      if (g->dupenames) {
    12991299        free(g->dupenames);
     
    13151315            sprintf(s, GetPString(IDS_GREPDUPECHECKPROGTEXT), y, g->numfiles);
    13161316            WinSetWindowText(g->hwndCurFile, s);
    1317             DosSleep(0L);
     1317            DosSleep(1);
    13181318          }
    13191319          y++;
     
    13741374                }
    13751375              }
    1376               else if (!(x % 100L))
    1377                 DosSleep(1L);
     1376              else if (!(x % 100))
     1377                DosSleep(1);
    13781378            }
    13791379            c = c->next;
  • trunk/dll/inis.c

    r761 r766  
    24092409                }
    24102410                else
    2411                   DosSleep(250L);
     2411                  DosSleep(250);
    24122412              }
    24132413            }
  • trunk/dll/presparm.c

    r689 r766  
    4949  if (!ppresparams)
    5050    return;
    51   ppresparams->cb = 0L;                 /* no entries yet */
     51  ppresparams->cb = 0;                  /* no entries yet */
    5252  pparam = ppresparams->aparam;         /* cast structure onto memory */
    5353
     
    6464                                 (PVOID) pparam->ab, QPF_NOINHERIT);
    6565  if (pparam->cb) {                     /* was the param found? */
    66     ppresparams->cb += 12L;             /* used 12 bytes */
    67     pparam = (PPARAM) (((ULONG) pparam) + 12L); /* advance 12 bytes to next memory location */
     66    ppresparams->cb += 12;              /* used 12 bytes */
     67    pparam = (PPARAM) (((ULONG) pparam) + 12);  /* advance 12 bytes to next memory location */
    6868  }
    6969
     
    7676                                 (PVOID) pparam->ab, QPF_NOINHERIT);
    7777  if (pparam->cb) {
    78     ppresparams->cb += 12L;
    79     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     78    ppresparams->cb += 12;
     79    pparam = (PPARAM) (((ULONG) pparam) + 12);
    8080  }
    8181
     
    8888                                 (PVOID) pparam->ab, QPF_NOINHERIT);
    8989  if (pparam->cb) {
    90     ppresparams->cb += 12L;
    91     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     90    ppresparams->cb += 12;
     91    pparam = (PPARAM) (((ULONG) pparam) + 12);
    9292  }
    9393
     
    100100                                 (PVOID) pparam->ab, QPF_NOINHERIT);
    101101  if (pparam->cb) {
    102     ppresparams->cb += 12L;
    103     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     102    ppresparams->cb += 12;
     103    pparam = (PPARAM) (((ULONG) pparam) + 12);
    104104  }
    105105
     
    112112                                 (PVOID) pparam->ab, QPF_NOINHERIT);
    113113  if (pparam->cb) {
    114     ppresparams->cb += 12L;
    115     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     114    ppresparams->cb += 12;
     115    pparam = (PPARAM) (((ULONG) pparam) + 12);
    116116  }
    117117
     
    124124                                 (PVOID) pparam->ab, QPF_NOINHERIT);
    125125  if (pparam->cb) {
    126     ppresparams->cb += 12L;
    127     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     126    ppresparams->cb += 12;
     127    pparam = (PPARAM) (((ULONG) pparam) + 12);
    128128  }
    129129
     
    136136                                 (PVOID) pparam->ab, QPF_NOINHERIT);
    137137  if (pparam->cb) {
    138     ppresparams->cb += 12L;
    139     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     138    ppresparams->cb += 12;
     139    pparam = (PPARAM) (((ULONG) pparam) + 12);
    140140  }
    141141
     
    143143  pparam->cb = WinQueryPresParam(hwnd,
    144144                                 PP_FONTNAMESIZE,
    145                                  0L,
    146                                  &pparam->id,
    147                                  36L, (PVOID) pparam->ab, QPF_NOINHERIT);
    148   if (pparam->cb) {
    149     ppresparams->cb += (pparam->cb + 8L);
    150     pparam = (PPARAM) (((ULONG) pparam) + pparam->cb + 8L);
     145                                 0,
     146                                 &pparam->id,
     147                                 36, (PVOID) pparam->ab, QPF_NOINHERIT);
     148  if (pparam->cb) {
     149    ppresparams->cb += (pparam->cb + 8);
     150    pparam = (PPARAM) (((ULONG) pparam) + pparam->cb + 8);
    151151  }
    152152
     
    159159                                 (PVOID) pparam->ab, QPF_NOINHERIT);
    160160  if (pparam->cb) {
    161     ppresparams->cb += 12L;
    162     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     161    ppresparams->cb += 12;
     162    pparam = (PPARAM) (((ULONG) pparam) + 12);
    163163  }
    164164
     
    171171                                 (PVOID) pparam->ab, QPF_NOINHERIT);
    172172  if (pparam->cb) {
    173     ppresparams->cb += 12L;
    174     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     173    ppresparams->cb += 12;
     174    pparam = (PPARAM) (((ULONG) pparam) + 12);
    175175  }
    176176
     
    184184                                 QPF_NOINHERIT | QPF_PURERGBCOLOR);
    185185  if (pparam->cb) {
    186     ppresparams->cb += 12L;
    187     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     186    ppresparams->cb += 12;
     187    pparam = (PPARAM) (((ULONG) pparam) + 12);
    188188  }
    189189
     
    197197                                 QPF_NOINHERIT | QPF_PURERGBCOLOR);
    198198  if (pparam->cb) {
    199     ppresparams->cb += 12L;
    200     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     199    ppresparams->cb += 12;
     200    pparam = (PPARAM) (((ULONG) pparam) + 12);
    201201  }
    202202
     
    210210                                 QPF_NOINHERIT | QPF_PURERGBCOLOR);
    211211  if (pparam->cb) {
    212     ppresparams->cb += 12L;
    213     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     212    ppresparams->cb += 12;
     213    pparam = (PPARAM) (((ULONG) pparam) + 12);
    214214  }
    215215
     
    223223                                 QPF_NOINHERIT | QPF_PURERGBCOLOR);
    224224  if (pparam->cb) {
    225     ppresparams->cb += 12L;
    226     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     225    ppresparams->cb += 12;
     226    pparam = (PPARAM) (((ULONG) pparam) + 12);
    227227  }
    228228
    229229  /* shadow color -- takes 12 bytes */
    230230  pparam->cb = WinQueryPresParam(hwnd,
    231                                  PP_SHADOW, 0L,
    232                                  &pparam->id,
    233                                  sizeof(LONG),
    234                                  (PVOID) pparam->ab, QPF_NOINHERIT);
    235   if (pparam->cb) {
    236     ppresparams->cb += 12L;
    237     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     231                                 PP_SHADOW, 0,
     232                                 &pparam->id,
     233                                 sizeof(LONG),
     234                                 (PVOID) pparam->ab, QPF_NOINHERIT);
     235  if (pparam->cb) {
     236    ppresparams->cb += 12;
     237    pparam = (PPARAM) (((ULONG) pparam) + 12);
    238238  }
    239239
     
    246246                                 (PVOID) pparam->ab, QPF_NOINHERIT);
    247247  if (pparam->cb) {
    248     ppresparams->cb += 12L;
    249     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     248    ppresparams->cb += 12;
     249    pparam = (PPARAM) (((ULONG) pparam) + 12);
    250250  }
    251251
     
    258258                                 (PVOID) pparam->ab, QPF_NOINHERIT);
    259259  if (pparam->cb) {
    260     ppresparams->cb += 12L;
    261     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     260    ppresparams->cb += 12;
     261    pparam = (PPARAM) (((ULONG) pparam) + 12);
    262262  }
    263263
     
    270270                                 (PVOID) pparam->ab, QPF_NOINHERIT);
    271271  if (pparam->cb) {
    272     ppresparams->cb += 12L;
    273     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     272    ppresparams->cb += 12;
     273    pparam = (PPARAM) (((ULONG) pparam) + 12);
    274274  }
    275275
     
    282282                                 (PVOID) pparam->ab, QPF_NOINHERIT);
    283283  if (pparam->cb) {
    284     ppresparams->cb += 12L;
    285     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     284    ppresparams->cb += 12;
     285    pparam = (PPARAM) (((ULONG) pparam) + 12);
    286286  }
    287287
     
    294294                                 (PVOID) pparam->ab, QPF_NOINHERIT);
    295295  if (pparam->cb) {
    296     ppresparams->cb += 12L;
    297     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     296    ppresparams->cb += 12;
     297    pparam = (PPARAM) (((ULONG) pparam) + 12);
    298298  }
    299299
     
    306306                                 (PVOID) pparam->ab, QPF_NOINHERIT);
    307307  if (pparam->cb) {
    308     ppresparams->cb += 12L;
    309     pparam = (PPARAM) (((ULONG) pparam) + 12L);
     308    ppresparams->cb += 12;
     309    pparam = (PPARAM) (((ULONG) pparam) + 12);
    310310  }
    311311
    312312  if (ppresparams->cb)
    313313    PrfWriteProfileData(prof,
    314                         appname, tagname, ppresparams, ppresparams->cb + 4L);
     314                        appname, tagname, ppresparams, ppresparams->cb + 4);
    315315
    316316  free(ppresparams);
     
    326326   */
    327327
    328   ULONG AttrFound, AttrValue[64], cbRetLen, x = 0L,
     328  ULONG AttrFound, AttrValue[64], cbRetLen, x = 0,
    329329    AttrName[] = { PP_FONTNAMESIZE, PP_BACKGROUNDCOLOR,
    330330    PP_FOREGROUNDCOLOR, PP_HILITEBACKGROUNDCOLOR,
    331331    PP_HILITEFOREGROUNDCOLOR, PP_BORDERCOLOR,
    332     0L
     332    0
    333333  };
    334334
     
    349349{
    350350  if (font)
    351     WinSetPresParam(hwnd, PP_FONTNAMESIZE, strlen(font) + 1L, (PVOID) font);
     351    WinSetPresParam(hwnd, PP_FONTNAMESIZE, strlen(font) + 1, (PVOID) font);
    352352  if (back)
    353353    WinSetPresParam(hwnd, PP_BACKGROUNDCOLOR, sizeof(RGB2), (PVOID) back);
     
    360360VOID IfNoParam(HWND hwnd, CHAR * keyroot, ULONG size, PVOID attrvalue)
    361361{
    362   ULONG fsize = 0L;
     362  ULONG fsize = 0;
    363363  CHAR s[81];
    364364
  • trunk/dll/printer.c

    r574 r766  
    4646  FILE *printhandle;
    4747  CHAR param = 0, data = 0;
    48   ULONG datalen = 1L, parmlen = 1L, htype, flagword;
     48  ULONG datalen = 1, parmlen = 1, htype, flagword;
    4949
    5050  if (!fWorkPlace)                      /* assume spooler is active */
     
    6262      return TRUE;
    6363    }
    64     if (DosDevIOCtl(fileno(printhandle), 5L, 0x00000066, (PVOID) & param,
    65                     1L, &parmlen, (PVOID) & data, 1L,
     64    if (DosDevIOCtl(fileno(printhandle), 5, 0x00000066, (PVOID) & param,
     65                    1, &parmlen, (PVOID) & data, 1,
    6666                    &datalen) != 0x00000100) {
    6767      fclose(printhandle);
     
    133133          if (StopPrinting)
    134134            break;
    135           DosRequestMutexSem(PrintSem, 240000L);
     135          DosRequestMutexSem(PrintSem, 240000);
    136136          if (StopPrinting)
    137137            break;
     
    266266                      if (prnformat && prnalt)
    267267                        skipping = (skipping) ? FALSE : TRUE;
    268                       DosSleep(1L);
     268                      DosSleep(1);
    269269                    }
    270270                  }
     
    309309          }
    310310          DosReleaseMutexSem(PrintSem);
    311           DosSleep(1L);
     311          DosSleep(1);
    312312        }
    313313        if (!StopPrinting)
  • trunk/dll/remap.c

    r689 r766  
    246246          if (!(driveflags[x] & DRIVE_IGNORE)) {
    247247            *s = (CHAR) x + 'A';
    248             if (!(ulDriveMap & (1L << x)))
     248            if (!(ulDriveMap & (1 << x)))
    249249              WinSendDlgItemMsg(hwnd,
    250250                                MAP_ATTACHLIST,
  • trunk/dll/saveclip.c

    r762 r766  
    6565          clip = (CHAR *) WinQueryClipbrdData(hab, CF_TEXT);
    6666        if (clip)
    67           len += strlen(clip) + 1L;
     67          len += strlen(clip) + 1;
    6868        if (!DosAllocSharedMem((PPVOID) & hold, (PSZ) NULL, len, PAG_COMMIT |
    6969                               OBJ_GIVEABLE | PAG_READ | PAG_WRITE)) {
     
    104104  CHAR *text = NULL, **clip = NULL;
    105105  INT x;
    106   ULONG len = 0L;
     106  ULONG len = 0;
    107107
    108108  if (list && list[0]) {
     
    434434            Runtime_Error(pszSrcFile, __LINE__, "_fsopen");
    435435          else {
    436             fseek(fp, 0L, SEEK_SET);
     436            fseek(fp, 0, SEEK_SET);
    437437            if (WinQueryButtonCheckstate(hwnd, SAV_APPEND) == 0)
    438               DosSetFileSize((HFILE) fileno(fp), 0L);
     438              DosSetFileSize((HFILE) fileno(fp), 0);
    439439            else
    440               fseek(fp, 0L, SEEK_END);
     440              fseek(fp, 0, SEEK_END);
    441441            while (pci && (INT) pci != -1) {
    442442              if (!(pci->rc.flRecordAttr & CRA_FILTERED)) {
     
    783783            Runtime_Error(pszSrcFile, __LINE__, "_fsopen");
    784784          else {
    785             fseek(fp, 0L, SEEK_SET);
     785            fseek(fp, 0, SEEK_SET);
    786786            if (WinQueryButtonCheckstate(hwnd, SAV_APPEND) == 0)
    787               DosSetFileSize((HFILE) fileno(fp), 0L);
     787              DosSetFileSize((HFILE) fileno(fp), 0);
    788788            else
    789               fseek(fp, 0L, SEEK_END);
     789              fseek(fp, 0, SEEK_END);
    790790            while (list[x]) {
    791791              hdir = HDIR_CREATE;
     
    798798                                &ffb4, sizeof(ffb4), &nm, FIL_QUERYEASIZE)) {
    799799                /* load the object's Subject, if required */
    800                 if (ffb4.cbList > 4L) {
     800                if (ffb4.cbList > 4) {
    801801                  APIRET rc;
    802802                  EAOP2 eaop;
     
    813813                    strcpy(pgea->szName, SUBJECT);
    814814                    pgea->cbName = strlen(pgea->szName);
    815                     pgea->oNextEntryOffset = 0L;
     815                    pgea->oNextEntryOffset = 0;
    816816                    pgealist->cbList = sizeof(GEA2LIST) + pgea->cbName;
    817817                    pfealist = xmallocz(1024, pszSrcFile, __LINE__);
     
    820820                      eaop.fpGEA2List = pgealist;
    821821                      eaop.fpFEA2List = pfealist;
    822                       eaop.oError = 0L;
     822                      eaop.oError = 0;
    823823                      rc = DosQueryPathInfo(list[x],
    824824                                            FIL_QUERYEASFROMLIST,
     
    839839                }
    840840                /* load the object's longname */
    841                 if (ffb4.cbList > 4L) {
     841                if (ffb4.cbList > 4) {
    842842                  APIRET rc;
    843843                  EAOP2 eaop;
     
    854854                    strcpy(pgea->szName, LONGNAME);
    855855                    pgea->cbName = strlen(pgea->szName);
    856                     pgea->oNextEntryOffset = 0L;
     856                    pgea->oNextEntryOffset = 0;
    857857                    pgealist->cbList = sizeof(GEA2LIST) + pgea->cbName;
    858858                    pfealist = xmallocz(1024, pszSrcFile, __LINE__);
  • trunk/dll/seeall.c

    r761 r766  
    493493                       (BACKGROUND | MINIMIZED)) |
    494494                      WAIT, HWND_DESKTOP, NULL, NULL, "%s", szBuffer);
    495               DosSleep(1L);
     495              DosSleep(1);
    496496              *p = 0;
    497497            }
     
    644644                goto Abort;
    645645              }
    646               DosSleep(1L);
     646              DosSleep(1);
    647647              if (mv.skip || !*mv.target)
    648648                break;
     
    11451145                                  (PSZ) NULL,
    11461146                                  0,
    1147                                   0L,
    1148                                   0L,
    1149                                   0L,
    1150                                   0L, 0L, HWND_TOP, SEEALL_OBJ, NULL, NULL);
     1147                                  0,
     1148                                  0,
     1149                                  0,
     1150                                  0, 0, HWND_TOP, SEEALL_OBJ, NULL, NULL);
    11511151        if (!hwndObj) {
    11521152          Win_Error2(HWND_OBJECT, HWND_DESKTOP, pszSrcFile, __LINE__,
     
    12901290          TileChildren(hwndMain, TRUE);
    12911291        WinSetWindowPos(hwndC, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
    1292         DosSleep(250L);
     1292        DosSleep(250);
    12931293      }
    12941294    }
    12951295    else {
    12961296      StartCollector(HWND_DESKTOP, 4);
    1297       DosSleep(250L);
     1297      DosSleep(250);
    12981298    }
    12991299  }
     
    13091309
    13101310  if (ad->afhead && ad->affiles) {
    1311     for (x = 0L; x < ad->affiles; x++) {
     1311    for (x = 0; x < ad->affiles; x++) {
    13121312      if (ad->afhead[x].fullname)
    13131313        free(ad->afhead[x].fullname);
     
    16251625  PostMsg(hwnd, UM_SETUP3, MPVOID, MPVOID);
    16261626  if (!pAD->stopflag && pAD->pfnCompare && pAD->afifiles) {
    1627     WinSendMsg(hwnd, UM_RESCAN, MPFROMLONG(1L), MPVOID);
     1627    WinSendMsg(hwnd, UM_RESCAN, MPFROMLONG(1), MPVOID);
    16281628    qsort(pAD->afindex, pAD->afifiles, sizeof(ALLFILES *), pAD->pfnCompare);
    16291629  }
     
    16521652          for (x = 0; x < ad->affiles; x++)
    16531653            ad->afhead[x].flags &= (~(AF_DUPE | AF_SELECTED));
    1654           DosSleep(1L);
     1654          DosSleep(1);
    16551655          for (x = 0; x < ad->affiles && !ad->stopflag; x++) {
    16561656            if (!(ad->afhead[x].flags & (AF_DUPE | AF_FILTERED))) {
     
    17201720                        goto SkipNonDupe;
    17211721                    }
    1722                     DosSleep(0);
     1722                    DosSleep(1);
    17231723                  }
    17241724                  ad->afhead[x].flags |= AF_DUPE;
     
    17281728                }
    17291729              }
    1730               DosSleep(1L);
     1730              DosSleep(1);
    17311731            }
    17321732          }
     
    20142014          DosError(FERR_DISABLEHARDERR);
    20152015          if (!DosQCurDisk(&ulDriveNum, &ulDriveMap)) {
    2016             for (x = 2L; x < 26L && !ad->stopflag; x++) {
    2017               if ((ulDriveMap & (1L << x)) && ad->abDrvFlags[x]) {
     2016            for (x = 2; x < 26 && !ad->stopflag; x++) {
     2017              if ((ulDriveMap & (1 << x)) && ad->abDrvFlags[x]) {
    20182018                *startname = (CHAR) (x + 'A');
    20192019                DoADir(hwnd, startname);
    20202020                PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
    2021                 DosSleep(1L);
     2021                DosSleep(1);
    20222022              }
    20232023            }
     
    20492049
    20502050    if (!ad->stopflag) {
    2051       PostMsg(hwnd, UM_RESCAN, MPFROMLONG(1L), MPVOID);
     2051      PostMsg(hwnd, UM_RESCAN, MPFROMLONG(1), MPVOID);
    20522052      ReSort(hwnd);
    20532053    }
     
    20792079      DosError(FERR_DISABLEHARDERR);
    20802080      if (!DosQCurDisk(&ulDriveNum, &ulDriveMap)) {
    2081         for (x = 2L; x < 26L && !ad->stopflag; x++) {
     2081        for (x = 2; x < 26 && !ad->stopflag; x++) {
    20822082          if (!(driveflags[x] & (DRIVE_IGNORE | DRIVE_INVALID))) {
    2083             if (ulDriveMap & (1L << x)) {
     2083            if (ulDriveMap & (1 << x)) {
    20842084              *startname = (CHAR) (x + 'A');
    20852085              sSelect = (SHORT) WinSendDlgItemMsg(hwnd, DRVS_LISTBOX,
     
    21362136                                              MPVOID);
    21372137        }
    2138         for (x = 2L; x < 26L; x++) {
     2138        for (x = 2; x < 26; x++) {
    21392139          if (ad->abDrvFlags[x]) {
    21402140            WinDismissDlg(hwnd, 1);
     
    25152515                      GetPString(IDS_COULDNTSTARTTHREADTEXT));
    25162516      else {
    2517         if (!DosCreateMutexSem(NULL, &pAD->hmtxScan, 0L, FALSE)) {
     2517        if (!DosCreateMutexSem(NULL, &pAD->hmtxScan, 0, FALSE)) {
    25182518          pAD->hwndStatus = WinCreateWindow(hwndFrame,
    25192519                                            WC_SEESTATUS,
     
    25622562      }
    25632563      else {
    2564         DosSleep(100L);
     2564        DosSleep(100);
    25652565        PostMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
    25662566        PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
     
    26032603        DosError(FERR_DISABLEHARDERR);
    26042604        if (!DosQCurDisk(&ulDriveNum, &ulDriveMap)) {
    2605           for (x = 2L; x < 26L && !pAD->stopflag; x++) {
    2606             if ((ulDriveMap & (1L << x)) && pAD->abDrvFlags[x]) {
     2605          for (x = 2; x < 26 && !pAD->stopflag; x++) {
     2606            if ((ulDriveMap & (1 << x)) && pAD->abDrvFlags[x]) {
    26072607              sprintf(&s[strlen(s)], "%s%c:", (once) ? ", " : " (", x + 'A');
    26082608              once = TRUE;
     
    30963096
    30973097        WinQueryPointerPos(HWND_DESKTOP, &ptl);
    3098         WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl, 1L);
     3098        WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl, 1);
    30993099        if ((SHORT) ptl.y == (SHORT) SHORT2FROMMP(mp1) &&
    31003100            (SHORT) ptl.x == (SHORT) SHORT1FROMMP(mp1) &&
    31013101            ((SHORT) ptl.y < 0 || ptl.y > (Rectl.yTop - Rectl.yBottom))) {
    31023102          PostMsg(hwnd, UM_MOUSEMOVE, mp1, MPVOID);
    3103           DosSleep(1L);
     3103          DosSleep(1);
    31043104        }
    31053105      }
     
    31153115      WinQueryWindowRect(hwnd, &Rectl);
    31163116      WinQueryPointerPos(HWND_DESKTOP, &ptl);
    3117       WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl, 1L);
     3117      WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl, 1);
    31183118      if ((SHORT) ptl.y == (SHORT) SHORT2FROMMP(mp1) &&
    31193119          (SHORT) ptl.x == (SHORT) SHORT1FROMMP(mp1) &&
    31203120          ((SHORT) ptl.y < 0 || ptl.y > (Rectl.yTop - Rectl.yBottom))) {
    3121         DosSleep(1L);
     3121        DosSleep(1);
    31223122        PostMsg(hwnd, WM_MOUSEMOVE, mp1, MPFROM2SHORT(TRUE, 0));
    31233123      }
     
    39273927        }
    39283928        WinSetPointer(HWND_DESKTOP, hptrBusy);
    3929         WinSendMsg(hwnd, UM_RESCAN, MPFROMLONG(1L), MPVOID);
     3929        WinSendMsg(hwnd, UM_RESCAN, MPFROMLONG(1), MPVOID);
    39303930        switch (SHORT1FROMMP(mp1)) {
    39313931        case IDM_SORTEASIZE:
     
    41694169      }
    41704170      else if (SHORT1FROMMP(mp1) == IDM_COLLECTOR) {
    4171         DosSleep(100L);
     4171        DosSleep(100);
    41724172        if (!PostMsg(hwnd, msg, mp1, mp2))
    41734173          WinSendMsg(hwnd, msg, mp1, mp2);
     
    42014201      pAD->stopflag = 1;
    42024202      if (pAD->hmtxScan) {
    4203         DosRequestMutexSem(pAD->hmtxScan, 15000L);
     4203        DosRequestMutexSem(pAD->hmtxScan, 15000);
    42044204        DosCloseMutexSem(pAD->hmtxScan);
    42054205      }
  • trunk/dll/select.c

    r762 r766  
    8787  register INT x;
    8888  BOOL foundone = FALSE;
    89   ULONG errs = 0L;
     89  ULONG errs = 0;
    9090
    9191  if (clearfirst && !deselect)
     
    141141        else
    142142          errs++;
    143         if (errs > 50L) {               /* prevent runaway on bad file */
     143        if (errs > 50) {                /* prevent runaway on bad file */
    144144
    145145          APIRET ret;
     
    151151          if (ret == MBID_NO)
    152152            break;
    153           errs = 0L;
     153          errs = 0;
    154154        }
    155155      }
     
    252252          }
    253253          free(input);
    254           DosSleep(1L);
     254          DosSleep(1);
    255255        }
    256256      }
     
    355355          }
    356356          free(input);
    357           DosSleep(1L);
     357          DosSleep(1);
    358358        }
    359359      }
     
    542542                                MPFROM2SHORT(CMA_FIRSTCHILD, CMA_ITEMORDER));
    543543    if (pci)
    544       DosSleep(1L);
     544      DosSleep(1);
    545545    while (pci && (INT)pci != -1) {
    546546      ExpandAll(hwndCnr, expand, pci);
     
    756756        }
    757757        if (!(x % 500))
    758           DosSleep(1L);
     758          DosSleep(1);
    759759        else if (!(x % 50))
    760760          DosSleep(1);
     
    778778      }
    779779      if (!(x % 500))
    780         DosSleep(1L);
     780        DosSleep(1);
    781781      else if (!(x % 50))
    782782        DosSleep(1);
     
    860860      }
    861861      if (!(x % 500))
    862         DosSleep(1L);
     862        DosSleep(1);
    863863      else if (!(x % 50))
    864864        DosSleep(1);
     
    879879      }
    880880      if (!(x % 500))
    881         DosSleep(1L);
     881        DosSleep(1);
    882882      else if (!(x % 50))
    883883        DosSleep(1);
     
    902902      }
    903903      if (!(x % 500))
    904         DosSleep(1L);
     904        DosSleep(1);
    905905      else if (!(x % 50))
    906906        DosSleep(1);
     
    924924      }
    925925      if (!(x % 500))
    926         DosSleep(1L);
     926        DosSleep(1);
    927927      else if (!(x % 50))
    928928        DosSleep(1);
     
    947947      }
    948948      if (!(x % 500))
    949         DosSleep(1L);
     949        DosSleep(1);
    950950      else if (!(x % 50))
    951951        DosSleep(1);
     
    970970      }
    971971      if (!(x % 500))
    972         DosSleep(1L);
     972        DosSleep(1);
    973973      else if (!(x % 50))
    974974        DosSleep(1);
     
    993993      }
    994994      if (!(x % 500))
    995         DosSleep(1L);
     995        DosSleep(1);
    996996      else if (!(x % 50))
    997997        DosSleep(1);
     
    10121012      }
    10131013      if (!(x % 500))
    1014         DosSleep(1L);
     1014        DosSleep(1);
    10151015      else if (!(x % 50))
    10161016        DosSleep(1);
     
    10341034      }
    10351035      if (!(x % 500))
    1036         DosSleep(1L);
     1036        DosSleep(1);
    10371037      else if (!(x % 50))
    10381038        DosSleep(1);
     
    10571057      }
    10581058      if (!(x % 500))
    1059         DosSleep(1L);
     1059        DosSleep(1);
    10601060      else if (!(x % 50))
    10611061        DosSleep(1);
     
    10801080      }
    10811081      if (!(x % 500))
    1082         DosSleep(1L);
     1082        DosSleep(1);
    10831083      else if (!(x % 50))
    10841084        DosSleep(1);
     
    11031103      }
    11041104      if (!(x % 500))
    1105         DosSleep(1L);
     1105        DosSleep(1);
    11061106      else if (!(x % 50))
    11071107        DosSleep(1);
     
    11261126      }
    11271127      if (!(x % 500))
    1128         DosSleep(1L);
     1128        DosSleep(1);
    11291129      else if (!(x % 50))
    11301130        DosSleep(1);
     
    13801380      DosSleep(1);
    13811381    }
    1382     DosSleep(1L);
     1382    DosSleep(1);
    13831383  }
    13841384
  • trunk/dll/seticon.c

    r574 r766  
    6565            break;
    6666          else {
    67             fseek(fp, 0L, SEEK_END);
     67            fseek(fp, 0, SEEK_END);
    6868            icf.cbIconData = ftell(fp);
    69             fseek(fp, 0L, SEEK_SET);
     69            fseek(fp, 0, SEEK_SET);
    7070            buff = xmalloc(icf.cbIconData, pszSrcFile, __LINE__);
    7171            if (!buff) {
  • trunk/dll/shadow.c

    r697 r766  
    246246      }
    247247      x++;
    248       DosSleep(1L);
     248      DosSleep(1);
    249249    }
    250250  }
  • trunk/dll/subj.c

    r551 r766  
    5050    strcpy(pgea->szName, SUBJECT);
    5151    pgea->cbName = strlen(pgea->szName);
    52     pgea->oNextEntryOffset = 0L;
     52    pgea->oNextEntryOffset = 0;
    5353    pgealist->cbList = (sizeof(GEA2LIST) + pgea->cbName);
    5454    pfealist = xmallocz(1024, pszSrcFile, __LINE__);
     
    5959      eaop.fpGEA2List = pgealist;
    6060      eaop.fpFEA2List = pfealist;
    61       eaop.oError = 0L;
     61      eaop.oError = 0;
    6262      rc = DosQueryPathInfo(filename, FIL_QUERYEASFROMLIST,
    6363                            (PVOID) & eaop, (ULONG) sizeof(EAOP2));
  • trunk/dll/sysinfo.c

    r551 r766  
    259259      CHAR s[134], dev;
    260260
    261       if (DosQuerySysInfo(QSV_MAX_PATH_LENGTH, QSV_MAX_COMP_LENGTH + 2L,
     261      if (DosQuerySysInfo(QSV_MAX_PATH_LENGTH, QSV_MAX_COMP_LENGTH + 2,
    262262                          (PVOID) vals, (ULONG) sizeof(vals))) {
    263263        WinDismissDlg(hwnd, 0);
     
    300300
    301301            sprintf(s, "%-28.28s%lu (", names[x], vals[x]);
    302             vals[x] /= 60000L;
    303             numdays = vals[x] / (60L * 24L);
     302            vals[x] /= 60000;
     303            numdays = vals[x] / (60 * 24);
    304304            if (numdays)
    305305              sprintf(s + strlen(s), "%lu day%s, ", numdays,
    306                       &"s"[numdays == 1L]);
    307             nummins = vals[x] % (60L * 24L);
     306                      &"s"[numdays == 1]);
     307            nummins = vals[x] % (60 * 24);
    308308            sprintf(s + strlen(s), "%luh:%02lum)", nummins / 60,
    309309                    nummins % 60);
  • trunk/dll/systemf.c

    r730 r766  
    171171              strcat(listfile, "\\");
    172172            sprintf(&listfile[strlen(listfile)], "%s%03x",
    173                     LISTTEMPROOT, (clock() & 4095L));
     173                    LISTTEMPROOT, (clock() & 4095));
    174174            fp = xfopen(listfile, "w",pszSrcFile,__LINE__);
    175175            if (fp) {
     
    231231          *pp = drive;
    232232        else {
    233           ULONG ulDriveNum = 3L, ulDriveMap;
     233          ULONG ulDriveNum = 3, ulDriveMap;
    234234
    235235          DosQCurDisk(&ulDriveNum, &ulDriveMap);
     
    11221122          for (ctr = 0;; ctr++)
    11231123          {
    1124             DosSleep(200L);
     1124            DosSleep(200);
    11251125            if (DosSetSession(ulSessID, &sd))   // Check if session gone (i.e. finished)
    11261126              break;
  • trunk/dll/tools.c

    r551 r766  
    900900      while (masks[x]) {
    901901        hDir = HDIR_CREATE;
    902         ulSearchCount = 1L;
     902        ulSearchCount = 1;
    903903        DosError(FERR_DISABLEHARDERR);
    904904        if (!DosFindFirst(masks[x],
     
    915915                       MPFROM2SHORT(LIT_SORTASCENDING, 0),
    916916                       MPFROMP(findbuf.achName));
    917             ulSearchCount = 1L;
     917            ulSearchCount = 1;
    918918          } while (!DosFindNext(hDir,
    919919                                &findbuf,
  • trunk/dll/treecnr.c

    r761 r766  
    188188      else
    189189        break;
    190       DosSleep(0L);
     190      DosSleep(1);
    191191    }
    192192    pci = FindCnrRecord(hwndCnr, dirname, NULL, TRUE, FALSE, TRUE);
     
    225225        else
    226226          break;
    227         DosSleep(0L);
     227        DosSleep(1);
    228228      }
    229229    }
     
    601601      dcd->hwndObject = hwnd;
    602602      if (ParentIsDesktop(hwnd, dcd->hwndParent))
    603         DosSleep(250L);
     603        DosSleep(250);
    604604    }
    605605    return 0;
     
    11351135                   MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
    11361136        cnri.cyLineSpacing = 0;
    1137         cnri.cxTreeIndent = 12L;
     1137        cnri.cxTreeIndent = 12;
    11381138        cnri.pSortRecord = (PVOID) SortTreeCnr;
    11391139        cnri.flWindowAttr &= (~(CV_NAME | CV_DETAIL | CV_TEXT));
     
    11771177        }
    11781178        else
    1179           DosSleep(1L);
     1179          DosSleep(1);
    11801180      }
    11811181    }
     
    11961196        if (!WinQueryPointerPos(HWND_DESKTOP, &ptl))
    11971197          break;
    1198         WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl, 1L);
     1198        WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl, 1);
    11991199      }
    12001200      else {
     
    17281728        DosError(FERR_DISABLEHARDERR);
    17291729        if (!DosQCurDisk(&ulDriveNum, &ulDriveMap)) {
    1730           if (!(ulDriveMap & 1L << (toupper(*pci->pszFileName) - 'A'))) {
     1730          if (!(ulDriveMap & 1 << (toupper(*pci->pszFileName) - 'A'))) {
    17311731            pciL = pciP = pci;
    17321732            for (;;) {
     
    22932293                        WalkAllDlgProc,
    22942294                        FM3ModHandle, WALK_FRAME, MPFROMP(dir)) && *dir)
    2295             WinSendMsg(hwnd, UM_SHOWME, MPFROMP(dir), MPFROMLONG(1L));
     2295            WinSendMsg(hwnd, UM_SHOWME, MPFROMP(dir), MPFROMLONG(1));
    22962296        }
    22972297        break;
     
    28052805      fOkayMinimize = TRUE;
    28062806      if (dcd->hwndObject && !fDummy) {
    2807         DosSleep(100L);
     2807        DosSleep(100);
    28082808        if (!fDummy) {
    28092809          fOkayMinimize = FALSE;
     
    28512851    }
    28522852    else
    2853       WinSendMsg(hwnd, UM_CLOSE, MPFROMLONG(1L), MPVOID);
     2853      WinSendMsg(hwnd, UM_CLOSE, MPFROMLONG(1), MPVOID);
    28542854    return 0;
    28552855
     
    30113011        // DbgMsg(pszSrcFile, __LINE__, "oldproc subclass %X", dcd->oldproc);   // 05 Jul 07 SHL
    30123012        // fixme to document 01 test?
    3013         if (dcd->oldproc == 0l)
     3013        if (dcd->oldproc == 0)
    30143014            Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
    30153015                     "WinSubclassWindow");
  • trunk/dll/valid.c

    r697 r766  
    450450  Status = DosQCurDisk(&ulDriveNum, &ulDriveMap);
    451451  if (!Status) {
    452     if (!(ulDriveMap & (1L << (ULONG) (toupper(drive) - 'A'))))
     452    if (!(ulDriveMap & (1 << (ULONG) (toupper(drive) - 'A'))))
    453453      return FALSE;
    454454    Path[0] = toupper(drive);
     
    688688  DosQCurDisk(&ulDriveNum, &ulDriveMap);
    689689  for (x = 0; x < 26; x++) {
    690     if (ulDriveMap & (1L << x) && !(driveflags[x] & DRIVE_IGNORE)) {
     690    if (ulDriveMap & (1 << x) && !(driveflags[x] & DRIVE_IGNORE)) {
    691691      {
    692692        CHAR s[80];
     
    710710      }
    711711    }
    712     else if (!(ulDriveMap & (1L << x)))
     712    else if (!(ulDriveMap & (1 << x)))
    713713      driveflags[x] |= DRIVE_INVALID;
    714714  }
     
    850850BOOL IsBinary(register CHAR * str, ULONG len)
    851851{
    852   register ULONG x = 0L;
     852  register ULONG x = 0;
    853853
    854854  if (str) {
     
    873873
    874874  if (filename) {
    875     if (!DosOpen(filename, &handle, &ulAction, 0L, 0L,
     875    if (!DosOpen(filename, &handle, &ulAction, 0, 0,
    876876                 OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
    877877                 OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
    878878                 OPEN_FLAGS_SEQUENTIAL | OPEN_SHARE_DENYNONE |
    879                  OPEN_ACCESS_READONLY, 0L)) {
     879                 OPEN_ACCESS_READONLY, 0)) {
    880880      len = 512;
    881881      rc = DosRead(handle, buff, len, &len);
     
    898898  HMODULE hmod = 0;
    899899  APIRET rc;
    900   ULONG startdrive = 3L;
     900  ULONG startdrive = 3;
    901901  CHAR objerr[CCHMAXPATH];
    902902
  • trunk/dll/viewer.c

    r593 r766  
    305305                         MLS_HSCROLL | MLS_VSCROLL | MLS_BORDER |
    306306                         WS_VISIBLE,
    307                          0L,
    308                          0L,
    309                          0L, 0L, hwnd, HWND_TOP, MLE_MLE, MPVOID, MPVOID)) {
     307                         0,
     308                         0,
     309                         0, 0, hwnd, HWND_TOP, MLE_MLE, MPVOID, MPVOID)) {
    310310      Win_Error2(hwnd, hwnd, pszSrcFile, __LINE__, IDS_WINCREATEWINDOW);
    311311    }
     
    403403      /* set up initial MLE conditions */
    404404      vw->srch.hwndmle = hwndMLE;
    405       MLEsetcurpos(hwndMLE, 0L);
     405      MLEsetcurpos(hwndMLE, 0);
    406406      MLEclearall(hwndMLE);
    407       MLEsetlimit(hwndMLE, -1L);
     407      MLEsetlimit(hwndMLE, -1);
    408408      MLEsetformat(hwndMLE, MLFIE_NOTRANS);
    409409      WinSetSysValue(HWND_DESKTOP, SV_INSERTMODE, TRUE);
     
    811811          if (fp) {
    812812            oldsize = filelength(fileno(fp));
    813             DosSetFileSize(fileno(fp), 0L);
     813            DosSetFileSize(fileno(fp), 0);
    814814            fclose(fp);
    815815          }
  • trunk/dll/viewinf.c

    r689 r766  
    8282      }
    8383      else {
    84         holdenv = xmalloc(strlen(env) + 2L, pszSrcFile, __LINE__);
     84        holdenv = xmalloc(strlen(env) + 2, pszSrcFile, __LINE__);
    8585        if (holdenv) {
    8686          strcpy(holdenv, env);
     
    107107                strcat(mask, "*.INF");
    108108              hdir = HDIR_CREATE;
    109               nm = 1L;
     109              nm = 1;
    110110              DosError(FERR_DISABLEHARDERR);
    111111              if (!DosFindFirst(mask, &hdir, FILE_NORMAL | FILE_ARCHIVED,
     
    127127                      }
    128128                      *title = 0;
    129                       fseek(fp, 107L, SEEK_SET);
     129                      fseek(fp, 107, SEEK_SET);
    130130                      fread(title, 1, CCHMAXPATH - 2, fp);
    131131                      title[CCHMAXPATH - 3] = 0;
     
    148148                                    MPFROMP(text));
    149149                Continue:
    150                   nm = 1L;
     150                  nm = 1;
    151151                } while (!DosFindNext(hdir, &ffb, sizeof(ffb), &nm));
    152152                DosFindClose(hdir);
     
    169169            repeating = TRUE;
    170170            if (PrfQueryProfileSize(fmprof, FM3Str, key, &size) && size) {
    171               holdenv = xmalloc(size + 2L, pszSrcFile, __LINE__);
     171              holdenv = xmalloc(size + 2, pszSrcFile, __LINE__);
    172172              if (holdenv) {
    173173                if (!PrfQueryProfileData(fmprof, FM3Str, key, holdenv, &size)) {
     
    449449                              VINF_LISTBOX,
    450450                              LM_SETITEMHANDLE,
    451                               MPFROM2SHORT(sSelect, 0), MPFROMLONG(1L));
     451                              MPFROM2SHORT(sSelect, 0), MPFROMLONG(1));
    452452          else
    453453            break;
  • trunk/dll/walkem.c

    r617 r766  
    366366  HDIR hDir = HDIR_CREATE;
    367367  SHORT sDrive;
    368   ULONG ulDriveNum, ulSearchCount = 1L, ulDriveMap;
     368  ULONG ulDriveNum, ulSearchCount = 1, ulDriveMap;
    369369
    370370  DosError(FERR_DISABLEHARDERR);
     
    378378    // Fill drive listbox
    379379    for (sDrive = 0; sDrive < 26; sDrive++) {
    380       if (ulDriveMap & (1L << sDrive)) {
     380      if (ulDriveMap & (1 << sDrive)) {
    381381        *szDrive = (CHAR) (sDrive + 'A');
    382382        if ((!nounwriteable || !(driveflags[sDrive] & DRIVE_NOTWRITEABLE)) &&
     
    420420          }
    421421        }
    422         ulSearchCount = 1L;
     422        ulSearchCount = 1;
    423423      } while (!DosFindNext(hDir,
    424424                            &findbuf, sizeof(FILEFINDBUF3), &ulSearchCount));
     
    508508                          QSV_BOOT_DRIVE,
    509509                          (PVOID) & bd, (ULONG) sizeof(ULONG)))
    510         bd = 3L;
     510        bd = 3;
    511511      *wa->szCurrentPath = (CHAR) bd + '@';
    512512    }
     
    534534          DosError(FERR_DISABLEHARDERR);
    535535          hDir = HDIR_CREATE;
    536           ulSearchCount = 1L;
     536          ulSearchCount = 1;
    537537          if (!IsRoot(info->path))
    538538            rc = DosFindFirst(info->path, &hDir, FILE_DIRECTORY |
     
    559559            }
    560560          }
    561           else if (!(ulDriveMap & (1L << (toupper(*info->path) - 'A')))) {
     561          else if (!(ulDriveMap & (1 << (toupper(*info->path) - 'A')))) {
    562562            temp = info->next;
    563563            remove_udir(info->path);
     
    575575          DosError(FERR_DISABLEHARDERR);
    576576          hDir = HDIR_CREATE;
    577           ulSearchCount = 1L;
     577          ulSearchCount = 1;
    578578          if (!IsRoot(info->path))
    579579            rc = DosFindFirst(info->path, &hDir, FILE_DIRECTORY |
     
    602602                              GetPString(IDS_WALKRECENTDIRSTEXT));
    603603          }
    604           else if (!(ulDriveMap & (1L << (toupper(*info->path) - 'A')))) {
     604          else if (!(ulDriveMap & (1 << (toupper(*info->path) - 'A')))) {
    605605            temp = info->next;
    606606            remove_ldir(info->path);
     
    726726        DosError(FERR_DISABLEHARDERR);
    727727        hDir = HDIR_CREATE;
    728         ulSearchCount = 1L;
     728        ulSearchCount = 1;
    729729        if (!IsRoot(szBuffer)) {
    730730          rc = DosFindFirst(szBuffer, &hDir, FILE_DIRECTORY |
     
    772772        DosError(FERR_DISABLEHARDERR);
    773773        hDir = HDIR_CREATE;
    774         ulSearchCount = 1L;
     774        ulSearchCount = 1;
    775775        if (!IsRoot(szBuffer)) {
    776776          rc = DosFindFirst(szBuffer,
     
    855855          DosError(FERR_DISABLEHARDERR);
    856856          hDir = HDIR_CREATE;
    857           ulSearchCount = 1L;
     857          ulSearchCount = 1;
    858858          if (!IsRoot(szBuff)) {
    859859            rc = DosFindFirst(szBuff,
     
    12181218          DosError(FERR_DISABLEHARDERR);
    12191219          hDir = HDIR_CREATE;
    1220           ulSearchCount = 1L;
     1220          ulSearchCount = 1;
    12211221          if (!IsRoot(szBuff)) {
    12221222            rc = DosFindFirst(szBuff,
     
    12831283          DosError(FERR_DISABLEHARDERR);
    12841284          hDir = HDIR_CREATE;
    1285           ulSearchCount = 1L;
     1285          ulSearchCount = 1;
    12861286          if (!IsRoot(szBuff)) {
    12871287            rc = DosFindFirst(szBuff,
  • trunk/dll/winlist.c

    r551 r766  
    8181        /* Get the switch list information */
    8282        ulcEntries = WinQuerySwitchList(0, NULL, 0);
    83         ulSize = sizeof(SWBLOCK) + sizeof(HSWITCH) + (ulcEntries + 4L) *
     83        ulSize = sizeof(SWBLOCK) + sizeof(HSWITCH) + (ulcEntries + 4) *
    8484          (LONG) sizeof(SWENTRY);
    8585        /* Allocate memory for list */
  • trunk/dll/worker.c

    r697 r766  
    898898                break;
    899899              }                         // switch
    900               DosSleep(0L);
     900              DosSleep(1);
    901901            }                           // for list
    902902
     
    936936              if (toupper(*wk->li->targetpath) < 'C')
    937937                DosBeep(1000, 25);      // Wake up user
    938               DosSleep(33L);
     938              DosSleep(33);
    939939              if (wk->li->type == IDM_WPSMOVE || wk->li->type == IDM_WPSCOPY)
    940                 DosSleep(96L);
     940                DosSleep(96);
    941941              break;
    942942            default:
     
    11131113                            wk->li->type == IDM_FAKEEXTRACTM) ?
    11141114                           wk->li->targetpath : NULL), NULL, "%s", szBuffer);
    1115                   DosSleep(1L);
     1115                  DosSleep(1);
    11161116                  *p = 0;
    11171117                }
     
    12691269                           (BACKGROUND | MINIMIZED)) |
    12701270                          WAIT, HWND_DESKTOP, NULL, NULL, "%s", szBuffer);
    1271                   DosSleep(1L);
     1271                  DosSleep(1);
    12721272                  *p = 0;
    12731273                }
     
    13191319                  if (!PostMsg(wk->hwndCnr,
    13201320                               UM_LOADFILE,
    1321                                MPFROMLONG(5L + viewtype), MPFROMP(temp)))
     1321                               MPFROMLONG(5 + viewtype), MPFROMP(temp)))
    13221322                    free(temp);
    13231323                }
    1324                 DosSleep(1L);
     1324                DosSleep(1);
    13251325              }
    13261326            }
     
    13621362                  if (!PostMsg(wk->hwndCnr,
    13631363                               UM_LOADFILE,
    1364                                MPFROMLONG(4L + viewtype), MPFROMP(temp)))
     1364                               MPFROMLONG(4 + viewtype), MPFROMP(temp)))
    13651365                    free(temp);
    13661366                }
    1367                 DosSleep(1L);
     1367                DosSleep(1);
    13681368              }
    13691369            }
  • trunk/vtree.c

    r551 r766  
    7171        }
    7272      }
    73       DosSleep(125L);
     73      DosSleep(125);
    7474      WinDestroyMsgQueue(hmq);
    7575    }
Note: See TracChangeset for help on using the changeset viewer.