rom/dos/matchnext.c

   1 /*
   2     Copyright © 1995-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: english
   7 */
   8 #include <exec/memory.h>
   9 #include <exec/types.h>
  10 #include <dos/dos.h>
  11 #include <proto/exec.h>
  12 #include "dos_intern.h"
  13 #include <string.h>
  14 #include <aros/debug.h>
  15
  16 /*****************************************************************************
  17
  18     NAME */
  19 #include <dos/dosasl.h>
  20 #include <proto/dos.h>
  21
  22         AROS_LH1(LONG, MatchNext,
  23
  24 /*  SYNOPSIS */
  25         AROS_LHA(struct AnchorPath *, AP, D1),
  26
  27 /*  LOCATION */
  28         struct DosLibrary *, DOSBase, 138, Dos)
  29
  30 /*  FUNCTION
  31         Find next file or directory that matches a given pattern.
  32         See <dos/dosasl.h> for more docs and how to control MatchNext().
  33
  34     INPUTS
  35         AP - pointer to Anchor Path structure which had been passed to
  36              MatchFirst() before.
  37
  38     RESULT
  39         Zero on success, or error code on failure.
  40
  41     NOTES
  42
  43     EXAMPLE
  44
  45     BUGS
  46
  47     SEE ALSO
  48         MatchFirst() MatchEnd() CurrentDir() Examine() ExNext()
  49         ParsePattern() <dos/dosasl.h>
  50
  51     INTERNALS
  52
  53 *****************************************************************************/
  54 {
  55     AROS_LIBFUNC_INIT
  56
  57     struct AChain       *ac = AP->ap_Current;
  58     BPTR                origdir;
  59     LONG                error = 0;
  60     BOOL                dir_changed = FALSE;
  61
  62     origdir = CurrentDir(0);
  63     CurrentDir(origdir);
  64
  65     AP->ap_Flags &= ~APF_DIDDIR;
  66
  67     /*
  68     ** Check if we are asked to enter a directory, but only do this
  69     ** if it is really possible
  70     */
  71
  72     if ((AP->ap_Flags & APF_DODIR) &&
  73         (ac->an_Flags & DDF_ExaminedBit) &&
  74         (ac->an_Info.fib_DirEntryType > 0) &&
  75         (ac->an_Child == NULL))
  76     {
  77         /*
  78         ** Alloc a new AChain. Make it the active one. Set its string to
  79         ** "#?" and mark it with DDF_AllBit Flag to indicate that this is a
  80         ** "APF_DODIR-AChain".  This is important for "back steppings",
  81         ** because "APF_DODIR-AChains" must be removed and freed then and
  82         ** the user must be notified about the leaving of a APF_DODIR-AChain
  83         ** with APF_DIDDIR.
  84         */
  85
  86         if ((ac->an_Child = Match_AllocAChain(1, DOSBase)))
  87         {
  88             ac->an_Child->an_Parent = ac;
  89             ac = ac->an_Child;
  90             AP->ap_Current = ac;
  91
  92             ac->an_String[0] = P_ANY;
  93             ac->an_String[1] = 0;
  94             ac->an_Flags = DDF_PatternBit | DDF_AllBit;
  95
  96             dir_changed = TRUE;
  97         }
  98
  99         /*
 100         ** If the allocation did not work, we simple ignore APF_DODIR. Just
 101         ** like if the user did not set this flag. Good idea or bad idea?
 102         */
 103     }
 104
 105
 106     /* Main loop for AChain traversing */
 107
 108     for(;;)
 109     {
 110         BOOL must_go_back = FALSE;
 111
 112         /* Check for user breaks (CTRL_C, ...) */
 113
 114         if (AP->ap_BreakBits)
 115         {
 116             AP->ap_FoundBreak = CheckSignal(AP->ap_BreakBits);
 117             if (AP->ap_FoundBreak)
 118             {
 119                 error = ERROR_BREAK;
 120                 goto done;
 121             }
 122         }
 123
 124         /* Check if AChain must be "setup" */
 125
 126         if (!(ac->an_Flags & DDF_ExaminedBit))
 127         {
 128             /*
 129             ** This AChain must be "setup". First AChain->an_Lock must point
 130             ** to the parent directory, that is the directory where this
 131             ** AChain is "in". !
 132             */
 133
 134             dir_changed = TRUE;
 135
 136             if (ac->an_Parent)
 137             {
 138                 CurrentDir(ac->an_Parent->an_Lock);
 139                 if (ac->an_Parent->an_Flags & DDF_PatternBit)
 140                 {
 141                     ac->an_Lock = Lock(ac->an_Parent->an_Info.fib_FileName, SHARED_LOCK);
 142                 }
 143                 else
 144                 {
 145                     ac->an_Lock = Lock(ac->an_Parent->an_String, SHARED_LOCK);
 146                 }
 147
 148                 if (!ac->an_Lock)
 149                 {
 150                     error = IoErr();
 151                     goto done;
 152                 }
 153             }
 154 #if !MATCHFUNCS_NO_DUPLOCK
 155             else
 156             {
 157                 ac->an_Lock = DupLock(origdir);
 158
 159                 if (!ac->an_Lock)
 160                 {
 161                     error = IoErr();
 162                     goto done;
 163                 }
 164
 165             }
 166 #else
 167             /*
 168             ** If there was no ac->an_Parent then we are dealing with the
 169             ** first AChain whose lock was already setup in
 170             ** Match_BuildAChainList
 171             */
 172 #endif
 173
 174             CurrentDir(ac->an_Lock);
 175
 176             if (ac->an_Flags & DDF_PatternBit)
 177             {
 178                 /*
 179                 ** If this is a pattern AChain we first Examine here our
 180                 ** parent directory, so that it then can be traversed with
 181                 ** ExNext
 182                 */
 183                 if (!Examine(ac->an_Lock, &ac->an_Info))
 184                 {
 185                     error = IoErr();
 186                     goto done;
 187                 }
 188                 ac->an_Flags |= DDF_ExaminedBit;
 189
 190             } /* if (ac->an_Flags & DDF_PatternBit) */
 191             else
 192             {
 193                 BPTR lock;
 194                 LONG success;
 195
 196                 /*
 197                 ** This is a normal AChain (no pattern). Try to lock it
 198                 ** to see if it exists.
 199                 */
 200
 201                 if (!(lock = Lock(ac->an_String, SHARED_LOCK)))
 202                 {
 203                     /* It does not exist, so if possible go back one step */
 204
 205                     if ((AP->ap_Flags & APF_ITSWILD) && (ac->an_Parent))
 206                     {
 207                         /* [2] */
 208
 209                         must_go_back = TRUE;
 210                     }
 211                     else
 212                     {
 213                         /* if going back is not possible get error code and exit */
 214                         error = IoErr();
 215                         goto done;
 216                     }
 217
 218                 } /* if (!(lock = Lock(ac->an_String, SHARED_LOCK))) */
 219                 else
 220                 {
 221                     /* The File/Direcory ac->an_String exists */
 222
 223                     success = Examine(lock, &ac->an_Info);
 224                     UnLock(lock);
 225
 226                     if (!success)
 227                     {
 228                         /*
 229                         ** Examine()ing the file/directory did not
 230                         ** work, although the lock was successful!?.
 231                         ** Get error code and exit
 232                         */
 233
 234                         error = IoErr();
 235                         goto done;
 236                     }
 237
 238                     /*
 239                     ** This strcpy is necessary, because in case
 240                     ** of empty ac->an_String("") fib_FileName would
 241                     ** get parent directory name which it must not!
 242                     */
 243
 244                     if (*ac->an_String == '\0')
 245                     {
 246                         strcpy(ac->an_Info.fib_FileName, ac->an_String);
 247                     }
 248
 249                     ac->an_Flags |= DDF_ExaminedBit;
 250
 251                     /*
 252                     ** If this is a file, but there are still more path
 253                     ** components to follow then we have to go back one step
 254                     ** (AChain)
 255                     */
 256
 257                     if (ac->an_Child && (ac->an_Info.fib_DirEntryType < 0))
 258                     {
 259                         /* [1] */
 260
 261                         must_go_back = TRUE;
 262                     }
 263
 264                     /*
 265                     ** Here we either have found a matching file/directory
 266                     ** (result) or, if ac->an_Child != NULL we have still to
 267                     ** continue walking through the AChains until we are in
 268                     ** the last one. This all happens further below
 269                     */
 270
 271                 } /* if (!(lock = Lock(ac->an_String, SHARED_LOCK))) else ... */
 272
 273             } /* if (ac->an_Flags & DDF_PatternBit) else ... */
 274
 275         } /* if (!(ac->an_Flags & DDF_ExaminedBit)) */
 276         else
 277         {
 278             /*
 279             ** This AChain was already setup.
 280             **
 281             ** When an AChain which is *not* a pattern already had
 282             ** DDF_PatternBit set, then this means ERROR_NO_MORE_ENTRIES, so
 283             ** we try to go back one step
 284             */
 285
 286             if (!(ac->an_Flags & DDF_PatternBit))
 287             {
 288                 /* [4] */
 289
 290                 must_go_back = TRUE;
 291             }
 292         }
 293
 294         /*
 295         ** Here we can be sure that the actual AChain is set up; i.e. it will
 296         ** have ac->an_Lock set correctly and to indicate this
 297         ** DDF_ExaminedBit was set
 298         */
 299
 300         CurrentDir(ac->an_Lock);
 301
 302         if (ac->an_Flags & DDF_PatternBit)
 303         {
 304             if(ExNext(ac->an_Lock, &ac->an_Info))
 305             {
 306                 if (MatchPatternNoCase(ac->an_String, ac->an_Info.fib_FileName))
 307                 {
 308                     /*
 309                     ** This file matches the pattern in ac->an_String. If
 310                     ** there are no more AChains to follow then we have
 311                     ** found a matching file/directory (a result)  -->
 312                     ** break.
 313                     */
 314
 315                     if (!ac->an_Child)
 316                     {
 317                         break;
 318                     }
 319                     else
 320                     {
 321                         if (ac->an_Info.fib_DirEntryType < 0)
 322                         {
 323                             /* This is a file, no chance to follow child
 324                                AChain. Go to top of "for(;;)" loop */
 325                             continue;
 326                         }
 327                     }
 328
 329                 } else {
 330                     /* Did not match. Go to top of "for(;;)" loop */
 331                     continue;
 332                 }
 333             }
 334             else
 335             {
 336                 error = IoErr();
 337                 if (error != ERROR_NO_MORE_ENTRIES) goto done;
 338
 339                 /* [3] */
 340
 341                 must_go_back = TRUE;
 342             }
 343
 344         } /* if (ac->an_Flags & DDF_PatternBit) */
 345
 346         /*
 347         ** Handle the cases where we must (try to) go back to the previous
 348         ** AChain.  This can happen if the actual AChain turned out to be a
 349         ** file although there are still more AChains to follow [1]. Or if
 350         ** the actual AChain did not exist at all [2]. Or if in a pattern
 351         ** AChain ExNext() told us that there are no more entries [3]. Or if
 352         ** we were getting to a normal (no pattern) AChain which was already
 353         ** set up (DDF_ExaminedBit) [4].
 354         */
 355
 356         if (must_go_back)
 357         {
 358             /* Check if going back is possible at all */
 359
 360             if (!ac->an_Parent)
 361             {
 362                 error = ERROR_NO_MORE_ENTRIES;
 363                 goto done;
 364             }
 365
 366             dir_changed = TRUE;
 367
 368             /* Yep. It is possible. So let's cleanup the AChain. */
 369
 370             CurrentDir(ac->an_Parent->an_Lock);
 371
 372             UnLock(ac->an_Lock);
 373
 374             ac->an_Lock = BNULL;
 375             ac->an_Flags &= ~DDF_ExaminedBit;
 376
 377             /* Make ac and AP->ap_Current point to the previous AChain */
 378
 379             AP->ap_Current = ac->an_Parent;
 380
 381             /*
 382             ** If this was an APF_DODIR Achain (indicated by DDF_AllBit)
 383             ** then the AChain must be unlinked and freed. And the user
 384             ** must be informed about the leaving with APF_DIDDIR and
 385             ** a "result" in AnchorPath which points to the directory which
 386             ** was leaved.
 387             */
 388
 389             if (ac->an_Flags & DDF_AllBit)
 390             {
 391                 AP->ap_Current->an_Child = NULL;
 392                 Match_FreeAChain(ac, DOSBase);
 393                 AP->ap_Flags |= APF_DIDDIR;
 394
 395                 /* go out of for(;;) loop --> MakeResult */
 396
 397                 break;
 398             }
 399
 400             ac = AP->ap_Current;
 401
 402         } /* if (must_go_back) */
 403         else
 404         {
 405             if (!ac->an_Child)
 406             {
 407                 /*
 408                 ** We have reached the last AChain. And this means that
 409                 ** we have found a matching file/directory :-)). Go out of
 410                 ** for(;;) loop --> MakeResult
 411                 */
 412
 413                 break;
 414             }
 415
 416             ac = ac->an_Child;
 417             AP->ap_Current = ac;
 418
 419             dir_changed = TRUE; /* CHECKME!!! Really? */
 420         }
 421
 422     } /* for(;;) */
 423
 424     error = Match_MakeResult(AP, DOSBase);
 425
 426 done:
 427     CurrentDir(origdir);
 428
 429     AP->ap_Flags &= ~APF_DODIR;
 430
 431     if (dir_changed)
 432     {
 433         AP->ap_Flags |= APF_DirChanged;
 434     }
 435     else
 436     {
 437         AP->ap_Flags &= ~APF_DirChanged;
 438     }
 439
 440     SetIoErr(error);
 441
 442     return error;
 443
 444     AROS_LIBFUNC_EXIT
 445
 446 } /* MatchNext */
 447