Changeset 551 for trunk/dll/copyf.c


Ignore:
Timestamp:
Feb 28, 2007, 2:33:51 AM (19 years ago)
Author:
Gregg Young
Message:

Indentation cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/copyf.c

    r347 r551  
    3838
    3939#ifndef WinMoveObject
    40   HOBJECT APIENTRY WinMoveObject(HOBJECT hObjectofObject,
    41                                  HOBJECT hObjectofDest,
    42                                  ULONG   ulReserved);
     40HOBJECT APIENTRY WinMoveObject(HOBJECT hObjectofObject,
     41                               HOBJECT hObjectofDest, ULONG ulReserved);
    4342#endif
    4443#ifndef WinCopyObject
    45   HOBJECT APIENTRY WinCopyObject(HOBJECT hObjectofObject,
    46                                  HOBJECT hObjectofDest,
    47                                  ULONG   ulReserved);
     44HOBJECT APIENTRY WinCopyObject(HOBJECT hObjectofObject,
     45                               HOBJECT hObjectofDest, ULONG ulReserved);
    4846#endif
    4947
    … …  
    5351#pragma alloc_text(UNLINKF,unlinkf,unlink_allf,make_deleteable,wipeallf)
    5452
    55 
    56 char *MakeTempName (char *buffer)
     53char *MakeTempName(char *buffer)
    5754{
    5855  FILESTATUS3 fs3;
    59   APIRET      rc;
    60   char       *p,*o;
     56  APIRET rc;
     57  char *p, *o;
    6158
    6259  p = o = buffer + strlen(buffer);
    63   sprintf(p,"%08lx.%03lx",clock(),mypid);
     60  sprintf(p, "%08lx.%03lx", clock(), mypid);
    6461  p = buffer + (strlen(buffer) - 1);
    65   for(;;) {
     62  for (;;) {
    6663    DosError(FERR_DISABLEHARDERR);
    67     rc = DosQueryPathInfo(buffer,FIL_STANDARD,&fs3,
    68                         (ULONG)sizeof(fs3));
    69     if(rc == ERROR_DISK_CHANGE) {
     64    rc = DosQueryPathInfo(buffer, FIL_STANDARD, &fs3, (ULONG) sizeof(fs3));
     65    if (rc == ERROR_DISK_CHANGE) {
    7066      DosError(FERR_ENABLEHARDERR);
    71       rc = DosQueryPathInfo(buffer,FIL_STANDARD,&fs3,
    72                           (ULONG)sizeof(fs3));
    73     }
    74     if(rc)
     67      rc = DosQueryPathInfo(buffer, FIL_STANDARD, &fs3, (ULONG) sizeof(fs3));
     68    }
     69    if (rc)
    7570      break;
    76 Loop:
    77     if(p < o) {
     71  Loop:
     72    if (p < o) {
    7873      *buffer = 0;
    7974      return NULL;
    8075    }
    81     if((*p) + 1 < 'Z' + 1) {
     76    if ((*p) + 1 < 'Z' + 1) {
    8277      (*p)++;
    83       while(strchr("*?<>\":/\\|+=;,[]. ",*p))
    84         (*p)++;
     78      while (strchr("*?<>\":/\\|+=;,[]. ", *p))
     79        (*p)++;
    8580      *p = toupper(*p);
    8681    }
    8782    else {
    8883      p--;
    89       if(p >= o && *p == '.')
    90         p--;
     84      if (p >= o && *p == '.')
     85        p--;
    9186      goto Loop;
    9287    }
    … …  
    9590}
    9691
    97 
    98 CHAR *TruncName (CHAR *oldname,CHAR *buffer)
    99 {
    100   CHAR       *p,*f,*s,*o;
     92CHAR *TruncName(CHAR * oldname, CHAR * buffer)
     93{
     94  CHAR *p, *f, *s, *o;
    10195  FILESTATUS3 fs3;
    102   APIRET      rc;
    103 
    104   if(!buffer || !oldname || !*oldname) {
    105     if(buffer)
     96  APIRET rc;
     97
     98  if (!buffer || !oldname || !*oldname) {
     99    if (buffer)
    106100      *buffer = 0;
    107101    return NULL;
    108102  }
    109   strcpy(buffer,oldname);
    110   f = strrchr(buffer,'\\');
    111   if(!f)
    112     f = strrchr(buffer,'/');
    113   if(!f)
     103  strcpy(buffer, oldname);
     104  f = strrchr(buffer, '\\');
     105  if (!f)
     106    f = strrchr(buffer, '/');
     107  if (!f)
    114108    f = buffer;
    115109  else
    … …  
    119113  f = oldname + (f - buffer);
    120114  strupr(buffer);
    121   while(*f == '.')  /* skip leading '.'s */
     115  while (*f == '.')                     /* skip leading '.'s */
    122116    f++;
    123117  s = f;
    124   while(*f && *f != '.' && f < s + 8) { /* skip past rootname */
     118  while (*f && *f != '.' && f < s + 8) {        /* skip past rootname */
    125119    *p = toupper(*f);
    126120    p++;
    127121    f++;
    128122  }
    129   while(*f == '.')
     123  while (*f == '.')
    130124    f++;
    131125  s = f;
    132   f = strrchr(f,'.');
    133   if(f) {
    134     while(*f == '.')
     126  f = strrchr(f, '.');
     127  if (f) {
     128    while (*f == '.')
    135129      f++;
    136130  }
    137   if(f && *(f + 1))
     131  if (f && *(f + 1))
    138132    s = f;
    139133  else
    140134    f = s;
    141   if(*f) {
     135  if (*f) {
    142136    *p = '.';
    143137    p++;
    144     while(*f && *f != '.' && f < s + 3) {
     138    while (*f && *f != '.' && f < s + 3) {
    145139      *p = toupper(*f);
    146140      p++;
    … …  
    151145
    152146  p = o;
    153   while(*p) {
    154     if(strchr("*?<>\":/\\|+=;,[] ",*p) || *p < 0x20)
     147  while (*p) {
     148    if (strchr("*?<>\":/\\|+=;,[] ", *p) || *p < 0x20)
    155149      *p = '_';
    156     if(*p == '.' && *(p + 1) == '.')
     150    if (*p == '.' && *(p + 1) == '.')
    157151      *(p + 1) = '_';
    158152    p++;
    … …  
    160154
    161155  p = o + (strlen(o) - 1);
    162   for(;;) {
     156  for (;;) {
    163157    DosError(FERR_DISABLEHARDERR);
    164     rc = DosQueryPathInfo(buffer,FIL_STANDARD,&fs3,
    165                         (ULONG)sizeof(fs3));
    166     if(rc == ERROR_DISK_CHANGE) {
     158    rc = DosQueryPathInfo(buffer, FIL_STANDARD, &fs3, (ULONG) sizeof(fs3));
     159    if (rc == ERROR_DISK_CHANGE) {
    167160      DosError(FERR_ENABLEHARDERR);
    168       rc = DosQueryPathInfo(buffer,FIL_STANDARD,&fs3,
    169                           (ULONG)sizeof(fs3));
    170     }
    171     if(rc)
     161      rc = DosQueryPathInfo(buffer, FIL_STANDARD, &fs3, (ULONG) sizeof(fs3));
     162    }
     163    if (rc)
    172164      break;
    173 Loop:
    174     if(p < o) {
     165  Loop:
     166    if (p < o) {
    175167      *buffer = 0;
    176168      return NULL;
    177169    }
    178     if((*p) + 1 < 'Z' + 1) {
     170    if ((*p) + 1 < 'Z' + 1) {
    179171      (*p)++;
    180       while(strchr("*?<>\":/\\|+=;,[]. ",*p))
    181         (*p)++;
     172      while (strchr("*?<>\":/\\|+=;,[]. ", *p))
     173        (*p)++;
    182174      *p = toupper(*p);
    183175    }
    184176    else {
    185177      p--;
    186       if(p >= o && *p == '.')
    187         p--;
     178      if (p >= o && *p == '.')
     179        p--;
    188180      goto Loop;
    189181    }
    … …  
    192184}
    193185
    194 
    195 CHAR *GetLongName (CHAR *oldname,CHAR *longname)
    196 {
    197   if(!longname)
     186CHAR *GetLongName(CHAR * oldname, CHAR * longname)
     187{
     188  if (!longname)
    198189    return NULL;
    199190  *longname = 0;
    200   if(!oldname ||
    201      !*oldname)
     191  if (!oldname || !*oldname)
    202192    return NULL;
    203   if(IsFullName(oldname)) {
    204 
    205     APIRET    rc;
    206     EAOP2     eaop;
     193  if (IsFullName(oldname)) {
     194
     195    APIRET rc;
     196    EAOP2 eaop;
    207197    PGEA2LIST pgealist;
    208198    PFEA2LIST pfealist;
    209     PGEA2     pgea;
    210     PFEA2     pfea;
    211     CHAR      *value;
    212 
    213     strcpy(longname,
    214            oldname);
     199    PGEA2 pgea;
     200    PFEA2 pfea;
     201    CHAR *value;
     202
     203    strcpy(longname, oldname);
    215204    value = longname;
    216     while(*value) {
    217       if(*value == '/')
    218         *value = '\\';
     205    while (*value) {
     206      if (*value == '/')
     207        *value = '\\';
    219208      value++;
    220209    }
    221     value = strrchr(longname,'\\');
    222     if(value) {
     210    value = strrchr(longname, '\\');
     211    if (value) {
    223212      value++;
    224213      *value = 0;
    225214    }
    226     pgealist = xmallocz(sizeof(GEA2LIST) + 32,pszSrcFile,__LINE__);
     215    pgealist = xmallocz(sizeof(GEA2LIST) + 32, pszSrcFile, __LINE__);
    227216    if (pgealist) {
    228217      pgea = &pgealist->list[0];
    229       strcpy(pgea->szName,LONGNAME);
     218      strcpy(pgea->szName, LONGNAME);
    230219      pgea->cbName = strlen(pgea->szName);
    231220      pgea->oNextEntryOffset = 0L;
    232221      pgealist->cbList = (sizeof(GEA2LIST) + pgea->cbName);
    233       pfealist = xmallocz(1536,pszSrcFile,__LINE__);
     222      pfealist = xmallocz(1536, pszSrcFile, __LINE__);
    234223      if (pfealist) {
    235         pfealist->cbList = 1024;
    236         eaop.fpGEA2List = pgealist;
    237         eaop.fpFEA2List = pfealist;
    238         eaop.oError = 0L;
    239         DosError(FERR_DISABLEHARDERR);
    240         rc = DosQueryPathInfo(oldname,
    241                               FIL_QUERYEASFROMLIST,
    242                               (PVOID)&eaop,
    243                               (ULONG)sizeof(EAOP2));
    244         if(!rc) {
    245           pfea = &eaop.fpFEA2List->list[0];
    246           value = pfea->szName + pfea->cbName + 1;
    247           value[pfea->cbValue] = 0;
    248           if(*(USHORT *)value == EAT_ASCII)
    249             strncat(longname,
    250                     value + (sizeof(USHORT) * 2),
    251                     CCHMAXPATH - strlen(longname));
    252           longname[CCHMAXPATH - 1] = 0;
    253         }
    254         free(pfealist);
     224        pfealist->cbList = 1024;
     225        eaop.fpGEA2List = pgealist;
     226        eaop.fpFEA2List = pfealist;
     227        eaop.oError = 0L;
     228        DosError(FERR_DISABLEHARDERR);
     229        rc = DosQueryPathInfo(oldname,
     230                              FIL_QUERYEASFROMLIST,
     231                              (PVOID) & eaop, (ULONG) sizeof(EAOP2));
     232        if (!rc) {
     233          pfea = &eaop.fpFEA2List->list[0];
     234          value = pfea->szName + pfea->cbName + 1;
     235          value[pfea->cbValue] = 0;
     236          if (*(USHORT *) value == EAT_ASCII)
     237            strncat(longname,
     238                    value + (sizeof(USHORT) * 2),
     239                    CCHMAXPATH - strlen(longname));
     240          longname[CCHMAXPATH - 1] = 0;
     241        }
     242        free(pfealist);
    255243      }
    256244      free(pgealist);
    … …  
    260248}
    261249
    262 
    263 BOOL ZapLongName (char *filename)
     250BOOL ZapLongName(char *filename)
    264251{
    265252  return WriteLongName(filename, "");
    266253}
    267254
    268 
    269 BOOL WriteLongName (CHAR *filename,CHAR *longname)
    270 {
    271   APIRET    rc;
    272   EAOP2     eaop;
     255BOOL WriteLongName(CHAR * filename, CHAR * longname)
     256{
     257  APIRET rc;
     258  EAOP2 eaop;
    273259  PFEA2LIST pfealist = NULL;
    274   ULONG     ealen;
    275   USHORT    len;
    276   CHAR     *eaval,*p;
    277 
    278   if(!filename ||
    279      !*filename ||
    280      !longname)
     260  ULONG ealen;
     261  USHORT len;
     262  CHAR *eaval, *p;
     263
     264  if (!filename || !*filename || !longname)
    281265    return FALSE;
    282   p = strrchr(longname,'\\');
    283   if(p)
    284     memmove(longname,
    285             p + 1,
    286             strlen(p + 1) + 1);
    287   p = strrchr(longname,'/');
    288   if(p)
    289     memmove(longname,
    290             p + 1,
    291             strlen(p + 1) + 1);
     266  p = strrchr(longname, '\\');
     267  if (p)
     268    memmove(longname, p + 1, strlen(p + 1) + 1);
     269  p = strrchr(longname, '/');
     270  if (p)
     271    memmove(longname, p + 1, strlen(p + 1) + 1);
    292272  bstrip(longname);
    293273  len = strlen(longname);
    294   if(len)
     274  if (len)
    295275    ealen = sizeof(FEA2LIST) + 10 + len + 4;
    296276  else
    297277    ealen = sizeof(FEALIST) + 10;
    298   rc = DosAllocMem((PPVOID)&pfealist,
    299                    ealen + 32L,
    300                    OBJ_TILE | PAG_COMMIT | PAG_READ | PAG_WRITE);
     278  rc = DosAllocMem((PPVOID) & pfealist,
     279                   ealen + 32L, OBJ_TILE | PAG_COMMIT | PAG_READ | PAG_WRITE);
    301280  if (rc)
    302     Dos_Error(MB_CANCEL,rc,HWND_DESKTOP,pszSrcFile,__LINE__,GetPString(IDS_OUTOFMEMORY));
     281    Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
     282              GetPString(IDS_OUTOFMEMORY));
    303283  else {
    304     memset(pfealist,
    305            0,
    306            ealen + 1);
     284    memset(pfealist, 0, ealen + 1);
    307285    pfealist->cbList = ealen;
    308286    pfealist->list[0].oNextEntryOffset = 0L;
    309287    pfealist->list[0].fEA = 0;
    310288    pfealist->list[0].cbName = 9;
    311     strcpy(pfealist->list[0].szName,
    312            LONGNAME);
    313     if(len) {
     289    strcpy(pfealist->list[0].szName, LONGNAME);
     290    if (len) {
    314291      eaval = pfealist->list[0].szName + 10;
    315       *(USHORT *)eaval = (USHORT)EAT_ASCII;
     292      *(USHORT *) eaval = (USHORT) EAT_ASCII;
    316293      eaval += sizeof(USHORT);
    317       *(USHORT *)eaval = (USHORT)len;
     294      *(USHORT *) eaval = (USHORT) len;
    318295      eaval += sizeof(USHORT);
    319       memcpy(eaval,
    320              longname,
    321              len);
     296      memcpy(eaval, longname, len);
    322297      pfealist->list[0].cbValue = len + (sizeof(USHORT) * 2);
    323298    }
    324299    else
    325300      pfealist->list[0].cbValue = 0;
    326     eaop.fpGEA2List = (PGEA2LIST)0;
     301    eaop.fpGEA2List = (PGEA2LIST) 0;
    327302    eaop.fpFEA2List = pfealist;
    328303    eaop.oError = 0L;
    329304    DosError(FERR_DISABLEHARDERR);
    330305    rc = DosSetPathInfo(filename,
    331                         FIL_QUERYEASIZE,
    332                         (PVOID)&eaop,
    333                         (ULONG)sizeof(EAOP2),
    334                         DSPI_WRTTHRU);
     306                        FIL_QUERYEASIZE,
     307                        (PVOID) & eaop, (ULONG) sizeof(EAOP2), DSPI_WRTTHRU);
    335308    DosFreeMem(pfealist);
    336     if(rc)
     309    if (rc)
    337310      return FALSE;
    338311  }
    … …  
    340313}
    341314
    342 
    343 BOOL AdjustWildcardName (CHAR *oldname,CHAR *newname)
     315BOOL AdjustWildcardName(CHAR * oldname, CHAR * newname)
    344316{
    345317  BOOL ret = FALSE;
    … …  
    347319  /* NOTE:  newname should be CCHMAXPATH chars long! */
    348320
    349   if(strchr(newname,'*') || strchr(newname,'?')) {
    350 
    351     CHAR srce[CCHMAXPATHCOMP],dest[CCHMAXPATHCOMP],result[CCHMAXPATHCOMP],*p;
    352 
    353     p = strrchr(newname,'\\');
    354     if(p && *(p + 1)) {
    355       strcpy(dest,p + 1);
    356       p = strrchr(oldname,'\\');
    357       if(p && *(p + 1)) {
    358         strcpy(srce,p + 1);
    359         DosError(FERR_DISABLEHARDERR);
    360         if(!DosEditName(1L,srce,dest,result,(ULONG)sizeof(result))) {
    361           p = strrchr(newname,'\\');
    362           p++;
    363           strcpy(p,result);
    364           ret = TRUE;
    365         }
     321  if (strchr(newname, '*') || strchr(newname, '?')) {
     322
     323    CHAR srce[CCHMAXPATHCOMP], dest[CCHMAXPATHCOMP], result[CCHMAXPATHCOMP],
     324      *p;
     325
     326    p = strrchr(newname, '\\');
     327    if (p && *(p + 1)) {
     328      strcpy(dest, p + 1);
     329      p = strrchr(oldname, '\\');
     330      if (p && *(p + 1)) {
     331        strcpy(srce, p + 1);
     332        DosError(FERR_DISABLEHARDERR);
     333        if (!DosEditName(1L, srce, dest, result, (ULONG) sizeof(result))) {
     334          p = strrchr(newname, '\\');
     335          p++;
     336          strcpy(p, result);
     337          ret = TRUE;
     338        }
    366339      }
    367340    }
    … …  
    370343}
    371344
    372 
    373 CHAR default_disk (VOID)
    374 {
    375   ULONG ulDriveNum,ulDriveMap;
     345CHAR default_disk(VOID)
     346{
     347  ULONG ulDriveNum, ulDriveMap;
    376348
    377349  DosError(FERR_DISABLEHARDERR);
    378   DosQCurDisk(&ulDriveNum,&ulDriveMap);
    379   return (CHAR)toupper((INT)ulDriveNum) + '@';
    380 }
    381 
     350  DosQCurDisk(&ulDriveNum, &ulDriveMap);
     351  return (CHAR) toupper((INT) ulDriveNum) + '@';
     352}
    382353
    383354#ifdef NEVER
    384355
    385 APIRET docopyallf (INT type,CHAR *oldname,CHAR *newname,...)
     356APIRET docopyallf(INT type, CHAR * oldname, CHAR * newname, ...)
    386357{
    387358  FILEFINDBUF3 fb;
    388   ULONG        nm;
    389   HDIR         hdir;
    390   APIRET       rc = 0;
    391   CHAR        *enddir,fullname[CCHMAXPATH];
    392 
    393   va_start(ap,newname);
    394   vsprintf(fullname,newname,ap);
     359  ULONG nm;
     360  HDIR hdir;
     361  APIRET rc = 0;
     362  CHAR *enddir, fullname[CCHMAXPATH];
     363
     364  va_start(ap, newname);
     365  vsprintf(fullname, newname, ap);
    395366  va_end(ap);
    396367
    397368  DosError(FERR_DISABLEHARDERR);
    398   if(!DosFindFirst(oldname)) {
     369  if (!DosFindFirst(oldname)) {
    399370    do {
    400371
    401372      /* build target name */
    402373
    403       if(fb.attrFile & FILE_DIRECTORY) {
    404         DosError(FERR_ENABLEHARDERR);
    405         rc = DosCreateDir();
    406         if(rc == ERROR_INVALID_NAME || rc == ERROR_FILENAME_EXCED_RANGE) {
    407 
    408           /* truncate directory name */
    409           /* create that directory   */
    410           /* update containers for name used */
    411 
    412         }
    413         rc = docopyallf(type,,"%s",);  /* recurse */
     374      if (fb.attrFile & FILE_DIRECTORY) {
     375        DosError(FERR_ENABLEHARDERR);
     376        rc = DosCreateDir();
     377        if (rc == ERROR_INVALID_NAME || rc == ERROR_FILENAME_EXCED_RANGE) {
     378
     379          /* truncate directory name */
     380          /* create that directory   */
     381          /* update containers for name used */
     382
     383        }
     384        rc = docopyallf(type,, "%s",);  /* recurse */
    414385      }
    415386      else
    416         rc = docopyf(type,,"%s",);     /* copy file */
     387        rc = docopyf(type,, "%s",);     /* copy file */
    417388      DosError(FERR_DISABLEHARDERR);
    418     } while(!rc && !DosFindNext());
     389    } while (!rc && !DosFindNext());
    419390    DosFindClose(hdir);
    420391  }
    … …  
    426397#endif
    427398
    428 
    429 APIRET docopyf (INT type,CHAR *oldname,CHAR *newname,...)
     399APIRET docopyf(INT type, CHAR * oldname, CHAR * newname, ...)
    430400{
    431401  /*
    … …  
    438408   */
    439409
    440   CHAR        fullnewname[CCHMAXPATH + 1],longname[CCHMAXPATH],
    441               shortname[CCHMAXPATH];
    442   CHAR        olddisk,newdisk,dir[CCHMAXPATH],*p,*pp;
    443   APIRET      ret = -1,rc;
    444   FILESTATUS3 st,st2,dummy;
    445   BOOL        diskchange = FALSE,zaplong = FALSE;
    446   va_list     ap;
     410  CHAR fullnewname[CCHMAXPATH + 1], longname[CCHMAXPATH],
     411    shortname[CCHMAXPATH];
     412  CHAR olddisk, newdisk, dir[CCHMAXPATH], *p, *pp;
     413  APIRET ret = -1, rc;
     414  FILESTATUS3 st, st2, dummy;
     415  BOOL diskchange = FALSE, zaplong = FALSE;
     416  va_list ap;
    447417
    448418  *fullnewname = *shortname = *dir = 0;
    449419
    450   va_start(ap,
    451            newname);
    452   vsprintf(fullnewname,
    453            newname,
    454            ap);
     420  va_start(ap, newname);
     421  vsprintf(fullnewname, newname, ap);
    455422  va_end(ap);
    456423
    457   if(!oldname ||
    458      !*oldname ||
    459      !*fullnewname)  /* bad string args */
    460     return (APIRET)-1;
     424  if (!oldname || !*oldname || !*fullnewname)   /* bad string args */
     425    return (APIRET) - 1;
    461426
    462427  DosError(FERR_DISABLEHARDERR);
    463   if(DosQueryPathInfo(oldname,
    464                       FIL_STANDARD,
    465                       &st,
    466                       sizeof(FILESTATUS3)))
    467     return (APIRET)-2;  /* no source */
    468 
    469   AdjustWildcardName(oldname,
    470                      fullnewname);
     428  if (DosQueryPathInfo(oldname, FIL_STANDARD, &st, sizeof(FILESTATUS3)))
     429    return (APIRET) - 2;                /* no source */
     430
     431  AdjustWildcardName(oldname, fullnewname);
    471432  MakeFullName(oldname);
    472433  MakeFullName(fullnewname);
    473   olddisk = toupper(*oldname);        /* source drive */
    474   newdisk = toupper(*fullnewname);    /* destination drive */
    475   if(!(driveflags[toupper(*oldname) - 'A'] & DRIVE_NOLONGNAMES))
     434  olddisk = toupper(*oldname);          /* source drive */
     435  newdisk = toupper(*fullnewname);      /* destination drive */
     436  if (!(driveflags[toupper(*oldname) - 'A'] & DRIVE_NOLONGNAMES))
    476437    *longname = 0;
    477   else
    478   {
     438  else {
    479439    GetLongName(oldname, longname);
    480     if(*longname) {
     440    if (*longname) {
    481441      p = RootName(longname);
    482       if(p != longname)
    483         memmove(longname, p, strlen(p) + 1);
     442      if (p != longname)
     443        memmove(longname, p, strlen(p) + 1);
    484444    }
    485445  }
    … …  
    487447  p = RootName(oldname);
    488448  pp = RootName(fullnewname);
    489   if(stricmp(p, pp))
    490   {
     449  if (stricmp(p, pp)) {
    491450    zaplong = TRUE;
    492451  }
    493452
    494453  DosError(FERR_DISABLEHARDERR);
    495   switch(type)
    496   {
    497     case WPSMOVE:
    498       {
    499         HOBJECT hobjsrc;
    500         HOBJECT hobjdest;
    501 
    502         ret = ERROR_FILE_NOT_FOUND;
    503         hobjsrc = WinQueryObject(oldname);
    504         if(hobjsrc) {
    505           strcpy(dir,
    506                  fullnewname);
    507           p = strrchr(dir,'\\');
    508           if(p < dir + 3)
    509             p++;
    510           *p = 0;
    511           ret = ERROR_PATH_NOT_FOUND;
    512           hobjdest = WinQueryObject(dir);
    513           if(hobjdest) {
    514             ret = ERROR_GEN_FAILURE;
    515             hobjsrc = WinMoveObject(hobjsrc,
    516                                     hobjdest,
    517                                     0);
    518             if(hobjsrc)
    519               ret = 0;
    520           }
    521         }
    522       }
    523       return ret;
    524 
    525     case WPSCOPY:
    526       {
    527         HOBJECT hobjsrc;
    528         HOBJECT hobjdest;
    529 
    530         ret = ERROR_FILE_NOT_FOUND;
    531         hobjsrc = WinQueryObject(oldname);
    532         if(hobjsrc) {
    533           strcpy(dir,
    534                  fullnewname);
    535           p = strrchr(dir,'\\');
    536           if(p < dir + 3)
    537             p++;
    538           *p = 0;
    539           ret = ERROR_PATH_NOT_FOUND;
    540           hobjdest = WinQueryObject(dir);
    541           if(hobjdest) {
    542             ret = ERROR_GEN_FAILURE;
    543             hobjsrc = WinCopyObject(hobjsrc,
    544                                     hobjdest,
    545                                     0);
    546             if(hobjsrc)
    547               ret = 0;
    548           }
    549         }
    550       }
    551       return ret;
    552 
    553     case MOVE:
    554       *dir = 0;
    555       if(olddisk == newdisk) {      /* same drive */
    556         /* make temporary copy in case move fails */
    557         if(IsFile(fullnewname) != -1 &&
    558            stricmp(oldname,
    559                    fullnewname)) {
    560           strcpy(dir,
    561                  fullnewname);
    562           p = strrchr(dir,'\\');
    563           if(p)
    564             *p = 0;
    565           strcat(dir,"\\");
    566           MakeTempName(dir);
    567           if(DosMove(fullnewname,
    568                      dir))
    569             *dir = 0;
    570         }
    571         DosError(FERR_DISABLEHARDERR);
    572         ret = DosMove(oldname,
    573                       fullnewname);   /* move it */
    574         if(ret &&
    575            *dir) { /* failed -- clean up */
    576           DosError(FERR_DISABLEHARDERR);
    577           if(!DosMove(dir,
    578                       fullnewname))
    579             Broadcast((HAB)0,
    580                       hwndMain,
    581                       UM_UPDATERECORD,
    582                       MPFROMP(dir),
    583                       MPVOID);
    584         }
    585         else if(!ret &&
    586                 *dir) {
    587           if(!IsFile(dir)) {
    588             if(!strchr(dir,'?') &&
    589                !strchr(dir,'*'))
    590               wipeallf("%s\\*",dir);
    591             DosError(FERR_DISABLEHARDERR);
    592             if(DosDeleteDir(dir)) {
    593               make_deleteable(dir);
    594               DosDeleteDir(dir);
    595             }
    596           }
    597           else if(IsFile(dir) > 0) {
    598             DosError(FERR_DISABLEHARDERR);
    599             if(DosForceDelete(dir)) {
    600               make_deleteable(dir);
    601               DosForceDelete(dir);
    602             }
    603             if(zaplong)
    604               ZapLongName(dir);
    605             Broadcast((HAB)0,
    606                       hwndMain,
    607                       UM_UPDATERECORD,
    608                       MPFROMP(dir),
    609                       MPVOID);
    610           }
    611         }
    612       }
    613       else {                          /* different drives */
    614         DosError(FERR_DISABLEHARDERR);
    615         ret = DosCopy(oldname,
    616                       fullnewname,
    617                       DCPY_EXISTING);   /* <=-NOTE! */
    618         if(ret == ERROR_DISK_CHANGE) {
    619           DosError(FERR_ENABLEHARDERR);
    620           ret = DosCopy(oldname,
    621                         fullnewname,
    622                         DCPY_EXISTING);
    623           diskchange = TRUE;
    624         }
    625         if(ret == ERROR_INVALID_NAME ||
    626            ret == ERROR_FILENAME_EXCED_RANGE) {
    627           if(TruncName(fullnewname,
    628                        shortname)) {  /* make 8.3 filename */
    629             DosError(FERR_DISABLEHARDERR);
    630             ret = DosCopy(oldname,
    631                           shortname,
    632                           DCPY_EXISTING);
    633             if(!ret) {  /* success -- write longname ea */
    634               WriteLongName(shortname,
    635                             fullnewname);
    636               strcpy(fullnewname,
    637                      shortname);
    638               /* broadcast fixup msg to windows */
    639               Broadcast((HAB)0,
    640                         hwndMain,
    641                         UM_UPDATERECORD,
    642                         MPFROMP(shortname),
    643                         MPVOID);
    644             }
    645           }
    646         }
    647         else if(!ret &&
    648                 *longname) {
    649 
    650           CHAR fixname[CCHMAXPATH];
    651 
    652           strcpy(fixname,
    653                  fullnewname);
    654           p = strrchr(fixname,'\\');
    655           if(p) {
    656             p++;
    657             *p = 0;
    658           }
    659           strcat(fixname,
    660                  longname);
    661           DosError(FERR_DISABLEHARDERR);
    662           DosMove(fullnewname,
    663                   fixname);
    664           strcpy(fullnewname,
    665                  fixname);
    666           if(zaplong)
    667             ZapLongName(fixname);
    668           Broadcast((HAB)0,
    669                     hwndMain,
    670                     UM_UPDATERECORD,
    671                     MPFROMP(fixname),
    672                     MPVOID);
    673         }
    674         if(!ret) {                        /* double-check success */
    675           DosError(FERR_DISABLEHARDERR);
    676           rc = DosQueryPathInfo(fullnewname,
    677                                 FIL_STANDARD,
    678                                 &st2,
    679                                 sizeof(FILESTATUS3));
    680           if(rc == ERROR_DISK_CHANGE) {
    681             DosError(FERR_ENABLEHARDERR);
    682             rc = DosQueryPathInfo(fullnewname,
    683                                   FIL_STANDARD,
    684                                   &st2,
    685                                   sizeof(FILESTATUS3));
    686           }
    687           if(!rc && st2.cbFile == st.cbFile) {   /* seems to have worked... */
    688             DosError(FERR_DISABLEHARDERR);
    689             if(diskchange) {
    690               DosError(FERR_ENABLEHARDERR);
    691               DosQueryPathInfo(oldname,
    692                                FIL_STANDARD,
    693                                &dummy,
    694                                sizeof(FILESTATUS3)); /* force disk change */
    695             }
    696             if(!(st2.attrFile & FILE_DIRECTORY))   /* erase file */
    697               unlinkf("%s",oldname);
    698             else {                                /* remove directory */
    699               wipeallf("%s\\*",oldname);
    700               DosError(FERR_DISABLEHARDERR);
    701               if(DosDeleteDir(oldname)) {
    702                 make_deleteable(oldname);
    703                 DosDeleteDir(oldname);
    704               }
    705             }
    706           }
    707         }
    708       }
    709       return ret;
    710 
    711     case COPY:
     454  switch (type) {
     455  case WPSMOVE:
     456    {
     457      HOBJECT hobjsrc;
     458      HOBJECT hobjdest;
     459
     460      ret = ERROR_FILE_NOT_FOUND;
     461      hobjsrc = WinQueryObject(oldname);
     462      if (hobjsrc) {
     463        strcpy(dir, fullnewname);
     464        p = strrchr(dir, '\\');
     465        if (p < dir + 3)
     466          p++;
     467        *p = 0;
     468        ret = ERROR_PATH_NOT_FOUND;
     469        hobjdest = WinQueryObject(dir);
     470        if (hobjdest) {
     471          ret = ERROR_GEN_FAILURE;
     472          hobjsrc = WinMoveObject(hobjsrc, hobjdest, 0);
     473          if (hobjsrc)
     474            ret = 0;
     475        }
     476      }
     477    }
     478    return ret;
     479
     480  case WPSCOPY:
     481    {
     482      HOBJECT hobjsrc;
     483      HOBJECT hobjdest;
     484
     485      ret = ERROR_FILE_NOT_FOUND;
     486      hobjsrc = WinQueryObject(oldname);
     487      if (hobjsrc) {
     488        strcpy(dir, fullnewname);
     489        p = strrchr(dir, '\\');
     490        if (p < dir + 3)
     491          p++;
     492        *p = 0;
     493        ret = ERROR_PATH_NOT_FOUND;
     494        hobjdest = WinQueryObject(dir);
     495        if (hobjdest) {
     496          ret = ERROR_GEN_FAILURE;
     497          hobjsrc = WinCopyObject(hobjsrc, hobjdest, 0);
     498          if (hobjsrc)
     499            ret = 0;
     500        }
     501      }
     502    }
     503    return ret;
     504
     505  case MOVE:
     506    *dir = 0;
     507    if (olddisk == newdisk) {           /* same drive */
     508      /* make temporary copy in case move fails */
     509      if (IsFile(fullnewname) != -1 && stricmp(oldname, fullnewname)) {
     510        strcpy(dir, fullnewname);
     511        p = strrchr(dir, '\\');
     512        if (p)
     513          *p = 0;
     514        strcat(dir, "\\");
     515        MakeTempName(dir);
     516        if (DosMove(fullnewname, dir))
     517          *dir = 0;
     518      }
    712519      DosError(FERR_DISABLEHARDERR);
    713       ret = DosCopy(oldname,
    714                     fullnewname,
    715                     DCPY_EXISTING);  /* <=-NOTE! */
    716       if(ret == ERROR_DISK_CHANGE) {
    717         DosError(FERR_ENABLEHARDERR);
    718         ret = DosCopy(oldname,
    719                       fullnewname,
    720                       DCPY_EXISTING);
    721         diskchange = TRUE;
    722       }
    723       if(ret == ERROR_INVALID_NAME ||
    724          ret == ERROR_FILENAME_EXCED_RANGE) {
    725         if(TruncName(fullnewname,
    726                      shortname)) {
    727           DosError((diskchange) ?
    728            FERR_ENABLEHARDERR :
    729            FERR_DISABLEHARDERR);
    730           ret = DosCopy(oldname,
    731                         shortname,
    732                         DCPY_EXISTING);
    733           if(!ret) {
    734             WriteLongName(shortname,
    735                           fullnewname);
    736             strcpy(fullnewname,
    737                    shortname);
    738             Broadcast((HAB)0,
    739                       hwndMain,
    740                       UM_UPDATERECORD,
    741                       MPFROMP(shortname),
    742                       MPVOID);
    743           }
    744         }
    745       }
    746       else if(!ret &&
    747               *longname) {
    748 
    749         CHAR fixname[CCHMAXPATH];
    750 
    751         strcpy(fixname,
    752                fullnewname);
    753         p = strrchr(fixname,'\\');
    754         if(p) {
    755           p++;
    756           *p = 0;
    757         }
    758         strcat(fixname,
    759                longname);
    760         DosError(FERR_DISABLEHARDERR);
    761         DosMove(fullnewname,
    762                 fixname);
    763         if(zaplong)
    764           ZapLongName(fixname);
    765         Broadcast((HAB)0,
    766                   hwndMain,
    767                   UM_UPDATERECORD,
    768                   MPFROMP(fixname),
    769                   MPVOID);
    770       }
    771       return ret;
    772 
    773     default:  /* shouldn't happen */
    774       Runtime_Error(pszSrcFile, __LINE__, "bad case %u", type);
    775       break;
    776   }
    777   return (APIRET)-3;  /* bad type */
    778 }
    779 
    780 
    781 INT make_deleteable (CHAR *filename)
     520      ret = DosMove(oldname, fullnewname);      /* move it */
     521      if (ret && *dir) {                /* failed -- clean up */
     522        DosError(FERR_DISABLEHARDERR);
     523        if (!DosMove(dir, fullnewname))
     524          Broadcast((HAB) 0, hwndMain, UM_UPDATERECORD, MPFROMP(dir), MPVOID);
     525      }
     526      else if (!ret && *dir) {
     527        if (!IsFile(dir)) {
     528          if (!strchr(dir, '?') && !strchr(dir, '*'))
     529            wipeallf("%s\\*", dir);
     530          DosError(FERR_DISABLEHARDERR);
     531          if (DosDeleteDir(dir)) {
     532            make_deleteable(dir);
     533            DosDeleteDir(dir);
     534          }
     535        }
     536        else if (IsFile(dir) > 0) {
     537          DosError(FERR_DISABLEHARDERR);
     538          if (DosForceDelete(dir)) {
     539            make_deleteable(dir);
     540            DosForceDelete(dir);
     541          }
     542          if (zaplong)
     543            ZapLongName(dir);
     544          Broadcast((HAB) 0, hwndMain, UM_UPDATERECORD, MPFROMP(dir), MPVOID);
     545        }
     546      }
     547    }
     548    else {                              /* different drives */
     549      DosError(FERR_DISABLEHARDERR);
     550      ret = DosCopy(oldname, fullnewname, DCPY_EXISTING);       /* <=-NOTE! */
     551      if (ret == ERROR_DISK_CHANGE) {
     552        DosError(FERR_ENABLEHARDERR);
     553        ret = DosCopy(oldname, fullnewname, DCPY_EXISTING);
     554        diskchange = TRUE;
     555      }
     556      if (ret == ERROR_INVALID_NAME || ret == ERROR_FILENAME_EXCED_RANGE) {
     557        if (TruncName(fullnewname, shortname)) {        /* make 8.3 filename */
     558          DosError(FERR_DISABLEHARDERR);
     559          ret = DosCopy(oldname, shortname, DCPY_EXISTING);
     560          if (!ret) {                   /* success -- write longname ea */
     561            WriteLongName(shortname, fullnewname);
     562            strcpy(fullnewname, shortname);
     563            /* broadcast fixup msg to windows */
     564            Broadcast((HAB) 0,
     565                      hwndMain, UM_UPDATERECORD, MPFROMP(shortname), MPVOID);
     566          }
     567        }
     568      }
     569      else if (!ret && *longname) {
     570
     571        CHAR fixname[CCHMAXPATH];
     572
     573        strcpy(fixname, fullnewname);
     574        p = strrchr(fixname, '\\');
     575        if (p) {
     576          p++;
     577          *p = 0;
     578        }
     579        strcat(fixname, longname);
     580        DosError(FERR_DISABLEHARDERR);
     581        DosMove(fullnewname, fixname);
     582        strcpy(fullnewname, fixname);
     583        if (zaplong)
     584          ZapLongName(fixname);
     585        Broadcast((HAB) 0,
     586                  hwndMain, UM_UPDATERECORD, MPFROMP(fixname), MPVOID);
     587      }
     588      if (!ret) {                       /* double-check success */
     589        DosError(FERR_DISABLEHARDERR);
     590        rc = DosQueryPathInfo(fullnewname,
     591                              FIL_STANDARD, &st2, sizeof(FILESTATUS3));
     592        if (rc == ERROR_DISK_CHANGE) {
     593          DosError(FERR_ENABLEHARDERR);
     594          rc = DosQueryPathInfo(fullnewname,
     595                                FIL_STANDARD, &st2, sizeof(FILESTATUS3));
     596        }
     597        if (!rc && st2.cbFile == st.cbFile) {   /* seems to have worked... */
     598          DosError(FERR_DISABLEHARDERR);
     599          if (diskchange) {
     600            DosError(FERR_ENABLEHARDERR);
     601            DosQueryPathInfo(oldname, FIL_STANDARD, &dummy, sizeof(FILESTATUS3));       /* force disk change */
     602          }
     603          if (!(st2.attrFile & FILE_DIRECTORY)) /* erase file */
     604            unlinkf("%s", oldname);
     605          else {                        /* remove directory */
     606            wipeallf("%s\\*", oldname);
     607            DosError(FERR_DISABLEHARDERR);
     608            if (DosDeleteDir(oldname)) {
     609              make_deleteable(oldname);
     610              DosDeleteDir(oldname);
     611            }
     612          }
     613        }
     614      }
     615    }
     616    return ret;
     617
     618  case COPY:
     619    DosError(FERR_DISABLEHARDERR);
     620    ret = DosCopy(oldname, fullnewname, DCPY_EXISTING); /* <=-NOTE! */
     621    if (ret == ERROR_DISK_CHANGE) {
     622      DosError(FERR_ENABLEHARDERR);
     623      ret = DosCopy(oldname, fullnewname, DCPY_EXISTING);
     624      diskchange = TRUE;
     625    }
     626    if (ret == ERROR_INVALID_NAME || ret == ERROR_FILENAME_EXCED_RANGE) {
     627      if (TruncName(fullnewname, shortname)) {
     628        DosError((diskchange) ? FERR_ENABLEHARDERR : FERR_DISABLEHARDERR);
     629        ret = DosCopy(oldname, shortname, DCPY_EXISTING);
     630        if (!ret) {
     631          WriteLongName(shortname, fullnewname);
     632          strcpy(fullnewname, shortname);
     633          Broadcast((HAB) 0,
     634                    hwndMain, UM_UPDATERECORD, MPFROMP(shortname), MPVOID);
     635        }
     636      }
     637    }
     638    else if (!ret && *longname) {
     639
     640      CHAR fixname[CCHMAXPATH];
     641
     642      strcpy(fixname, fullnewname);
     643      p = strrchr(fixname, '\\');
     644      if (p) {
     645        p++;
     646        *p = 0;
     647      }
     648      strcat(fixname, longname);
     649      DosError(FERR_DISABLEHARDERR);
     650      DosMove(fullnewname, fixname);
     651      if (zaplong)
     652        ZapLongName(fixname);
     653      Broadcast((HAB) 0, hwndMain, UM_UPDATERECORD, MPFROMP(fixname), MPVOID);
     654    }
     655    return ret;
     656
     657  default:                              /* shouldn't happen */
     658    Runtime_Error(pszSrcFile, __LINE__, "bad case %u", type);
     659    break;
     660  }
     661  return (APIRET) - 3;                  /* bad type */
     662}
     663
     664INT make_deleteable(CHAR * filename)
    782665{
    783666  INT ret = -1;
    … …  
    785668
    786669  DosError(FERR_DISABLEHARDERR);
    787   if(!DosQueryPathInfo(filename,
    788                        FIL_STANDARD,
    789                        &fsi,
    790                        sizeof(FILESTATUS3))) {
     670  if (!DosQueryPathInfo(filename, FIL_STANDARD, &fsi, sizeof(FILESTATUS3))) {
    791671    fsi.attrFile = 0;
    792672    DosError(FERR_DISABLEHARDERR);
    793     if(!DosSetPathInfo(filename,
    794                        FIL_STANDARD,
    795                        &fsi,
    796                        sizeof(FILESTATUS3),
    797                        0L))
     673    if (!DosSetPathInfo(filename,
     674                        FIL_STANDARD, &fsi, sizeof(FILESTATUS3), 0L))
    798675      ret = 0;
    799676  }
    … …  
    801678}
    802679
    803 
    804 INT wipeallf (CHAR *string,...)
     680INT wipeallf(CHAR * string, ...)
    805681{
    806682  /* unlink everything from directory on down... */
    807683
    808   FILEFINDBUF3  *f;
    809   HDIR          search_handle;
    810   ULONG         num_matches;
    811   CHAR          *p,*ss,*str;
    812   CHAR          s[CCHMAXPATH],mask[257];
    813   va_list       ap;
    814   INT           rc;
    815 
    816   va_start(ap,string);
    817   vsprintf(s,string,ap);
     684  FILEFINDBUF3 *f;
     685  HDIR search_handle;
     686  ULONG num_matches;
     687  CHAR *p, *ss, *str;
     688  CHAR s[CCHMAXPATH], mask[257];
     689  va_list ap;
     690  INT rc;
     691
     692  va_start(ap, string);
     693  vsprintf(s, string, ap);
    818694  va_end(ap);
    819695
    820   if(!*s)
     696  if (!*s)
    821697    return -1;
    822698  p = s;
    823   while((p = strchr(p,'/')) != NULL) {
     699  while ((p = strchr(p, '/')) != NULL) {
    824700    *p = '\\';
    825701    p++;
    826702  }
    827703
    828   str = xstrdup(s,pszSrcFile,__LINE__);
    829   if(!str)
     704  str = xstrdup(s, pszSrcFile, __LINE__);
     705  if (!str)
    830706    return -1;
    831707
    832   { /* safety net -- disallow deleting a root dir or partial name */
     708  {                                     /* safety net -- disallow deleting a root dir or partial name */
    833709    CHAR temp;
    834710
    835     p = strrchr(str,'\\');
    836     if(p) {
     711    p = strrchr(str, '\\');
     712    if (p) {
    837713      p++;
    838714      temp = *p;
    839715      *p = 0;
    840       if(IsRoot(str) || !IsFullName(str)) {
    841         /* under no circumstances! */
    842         Runtime_Error(pszSrcFile, __LINE__, "bad name %s", str);
    843         free(str);
    844         return -1;
     716      if (IsRoot(str) || !IsFullName(str)) {
     717        /* under no circumstances! */
     718        Runtime_Error(pszSrcFile, __LINE__, "bad name %s", str);
     719        free(str);
     720        return -1;
    845721      }
    846722      *p = temp;
    … …  
    849725
    850726  p = s;
    851   p = strrchr(s,'\\');           /* strip s to just path */
    852   if(!p)
    853     p = strrchr(s,':');
    854   if(p) {
     727  p = strrchr(s, '\\');                 /* strip s to just path */
     728  if (!p)
     729    p = strrchr(s, ':');
     730  if (p) {
    855731    p++;
    856     strncpy(mask,p,256);
     732    strncpy(mask, p, 256);
    857733    mask[256] = 0;
    858734    *p = 0;
    … …  
    863739  }
    864740
    865   ss = xmalloc(CCHMAXPATH,pszSrcFile,__LINE__);
    866   f = xmalloc(sizeof(FILEFINDBUF3),pszSrcFile,__LINE__);
     741  ss = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__);
     742  f = xmalloc(sizeof(FILEFINDBUF3), pszSrcFile, __LINE__);
    867743  if (!ss || !f) {
    868744    xfree(ss);
    … …  
    876752
    877753  DosError(FERR_DISABLEHARDERR);
    878   if(!DosFindFirst(str,&search_handle,FILE_NORMAL | FILE_DIRECTORY |
    879      FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN | FILE_ARCHIVED,f,
    880      sizeof(FILEFINDBUF3),&num_matches,FIL_STANDARD)) {
    881 
    882     strcpy(ss,s);
     754  if (!DosFindFirst(str, &search_handle, FILE_NORMAL | FILE_DIRECTORY |
     755                    FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN | FILE_ARCHIVED,
     756                    f, sizeof(FILEFINDBUF3), &num_matches, FIL_STANDARD)) {
     757
     758    strcpy(ss, s);
    883759    p = &ss[strlen(ss)];
    884760
    885761    do {
    886       strcpy(p,f->achName);
    887       if(f->attrFile & FILE_DIRECTORY) {
    888         if(strcmp(f->achName,".") && strcmp(f->achName,"..")) {
    889           wipeallf("%s/%s",ss,mask);    /* recurse to wipe files */
    890           DosError(FERR_DISABLEHARDERR);
    891           if(DosDeleteDir(ss)) {               /* remove directory */
    892             make_deleteable(ss);
    893             DosError(FERR_DISABLEHARDERR);
    894             DosDeleteDir(ss);
    895           }
    896         }
     762      strcpy(p, f->achName);
     763      if (f->attrFile & FILE_DIRECTORY) {
     764        if (strcmp(f->achName, ".") && strcmp(f->achName, "..")) {
     765          wipeallf("%s/%s", ss, mask);  /* recurse to wipe files */
     766          DosError(FERR_DISABLEHARDERR);
     767          if (DosDeleteDir(ss)) {       /* remove directory */
     768            make_deleteable(ss);
     769            DosError(FERR_DISABLEHARDERR);
     770            DosDeleteDir(ss);
     771          }
     772        }
    897773      }
    898774      else {
    899         DosError(FERR_DISABLEHARDERR);
    900         if(DosForceDelete(ss)) {
    901           make_deleteable(ss);
    902           DosError(FERR_DISABLEHARDERR);
    903           rc = (INT)DosForceDelete(ss);
    904           if(rc)
    905             return rc;
    906         }
     775        DosError(FERR_DISABLEHARDERR);
     776        if (DosForceDelete(ss)) {
     777          make_deleteable(ss);
     778          DosError(FERR_DISABLEHARDERR);
     779          rc = (INT) DosForceDelete(ss);
     780          if (rc)
     781            return rc;
     782        }
    907783      }
    908784      num_matches = 1L;
    909785      DosError(FERR_DISABLEHARDERR);
    910     } while(!DosFindNext(search_handle,f,sizeof(FILEFINDBUF3),
    911                          &num_matches));
     786    } while (!DosFindNext(search_handle, f, sizeof(FILEFINDBUF3),
     787                          &num_matches));
    912788    DosFindClose(search_handle);
    913789  }
    … …  
    919795}
    920796
    921 
    922 INT unlink_allf (CHAR *string,...)
     797INT unlink_allf(CHAR * string, ...)
    923798{
    924799  /* wildcard delete */
    925800
    926801  FILEFINDBUF3 *f;
    927   HDIR  search_handle;
     802  HDIR search_handle;
    928803  ULONG num_matches;
    929   CHAR  *p,*ss,*str;
    930   CHAR  s[CCHMAXPATH];
     804  CHAR *p, *ss, *str;
     805  CHAR s[CCHMAXPATH];
    931806  va_list ap;
    932807
    933   va_start(ap,string);
    934   vsprintf(s,string,ap);
     808  va_start(ap, string);
     809  vsprintf(s, string, ap);
    935810  va_end(ap);
    936811
    937   if(!*s)
     812  if (!*s)
    938813    return -1;
    939814  p = s;
    940   while((p = strchr(p,'/')) != NULL) {
     815  while ((p = strchr(p, '/')) != NULL) {
    941816    *p = '\\';
    942817    p++;
    943818  }
    944819
    945   str = xstrdup(s,pszSrcFile,__LINE__);
     820  str = xstrdup(s, pszSrcFile, __LINE__);
    946821  if (!str)
    947822    return -1;
    948823
    949824  p = s;
    950   p = strrchr(s,'\\');           /* strip s to just path */
    951   if(!p)
    952     p = strrchr(s,':');
    953   if(p) {
     825  p = strrchr(s, '\\');                 /* strip s to just path */
     826  if (!p)
     827    p = strrchr(s, ':');
     828  if (p) {
    954829    p++;
    955830    *p = 0;
    … …  
    958833    *s = 0;
    959834
    960   ss = xmalloc(CCHMAXPATH,pszSrcFile,__LINE__);
    961   f = xmalloc(sizeof(FILEFINDBUF3),pszSrcFile,__LINE__);
     835  ss = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__);
     836  f = xmalloc(sizeof(FILEFINDBUF3), pszSrcFile, __LINE__);
    962837  if (!ss || !f) {
    963838    xfree(ss);
    … …  
    971846
    972847  DosError(FERR_DISABLEHARDERR);
    973   if(!DosFindFirst(str,&search_handle,FILE_NORMAL,f,
    974      sizeof(FILEFINDBUF3),&num_matches,FIL_STANDARD)) {
    975 
    976     strcpy(ss,s);
     848  if (!DosFindFirst(str, &search_handle, FILE_NORMAL, f,
     849                    sizeof(FILEFINDBUF3), &num_matches, FIL_STANDARD)) {
     850
     851    strcpy(ss, s);
    977852    p = &ss[strlen(ss)];
    978853
    979854    do {
    980       strcpy(p,f->achName);
    981       unlinkf("%s",ss);
     855      strcpy(p, f->achName);
     856      unlinkf("%s", ss);
    982857      num_matches = 1L;
    983858      DosError(FERR_DISABLEHARDERR);
    984     } while(!DosFindNext(search_handle,f,sizeof(FILEFINDBUF3),
    985                          &num_matches));
     859    } while (!DosFindNext(search_handle, f, sizeof(FILEFINDBUF3),
     860                          &num_matches));
    986861    DosFindClose(search_handle);
    987862  }
    … …  
    993868}
    994869
    995 
    996 INT unlinkf (CHAR *string,...)
     870INT unlinkf(CHAR * string, ...)
    997871{
    998872  CHAR buffer[CCHMAXPATH];
    999873  va_list ap;
    1000874
    1001   va_start(ap,string);
    1002   vsprintf(buffer,string,ap);
     875  va_start(ap, string);
     876  vsprintf(buffer, string, ap);
    1003877  va_end(ap);
    1004878
    1005   if(!strstr(buffer,ArcTempRoot)) {
     879  if (!strstr(buffer, ArcTempRoot)) {
    1006880    DosError(FERR_DISABLEHARDERR);
    1007     if(DosDelete(buffer)) {
     881    if (DosDelete(buffer)) {
    1008882      make_deleteable(buffer);
    1009883      DosError(FERR_DISABLEHARDERR);
    … …  
    1013887  else {
    1014888    DosError(FERR_DISABLEHARDERR);
    1015     if(DosForceDelete(buffer)) {
     889    if (DosForceDelete(buffer)) {
    1016890      make_deleteable(buffer);
    1017891      DosError(FERR_DISABLEHARDERR);
    … …  
    1021895  return 0;
    1022896}
    1023 
Note: See TracChangeset for help on using the changeset viewer.