rom/dos/match_old.c

   1 matchfirst.c:
   2
   3
   4
   5 /*
   6     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   7     $Id$
   8
   9     Desc:
  10     Lang: english
  11 */
  12 #include "dos_intern.h"
  13 #include <proto/exec.h>
  14 #include <exec/memory.h>
  15 #include <exec/types.h>
  16 #include <dos/dos.h>
  17
  18 /*****************************************************************************
  19
  20     NAME */
  21 #include <dos/dosasl.h>
  22 #include <proto/dos.h>
  23
  24         AROS_LH2(LONG, MatchFirst,
  25
  26 /*  SYNOPSIS */
  27         AROS_LHA(STRPTR             , pat, D1),
  28         AROS_LHA(struct AnchorPath *, AP , D2),
  29
  30 /*  LOCATION */
  31         struct DosLibrary *, DOSBase, 137, Dos)
  32
  33 /*  FUNCTION
  34
  35         Searches for the first file or directory that matches a given pattern.
  36         MatchFirst() initializes the AnchorPath structure for you but you
  37         must initilize the following fields: ap_Flags, ap_Strlen, ap_BreakBits
  38         and ap_FoundBreak. The first call to MatchFirst() also passes you
  39         the first matching file which you can examine in ap_Info and the directory
  40         the files is in in ap_Current->an_Lock. After the first call to
  41         MatchFirst() call MatchNext().
  42         The search begins whereever the current directory is set to. See
  43         CurrentDir();
  44         For more info on patterns see ParsePattern().
  45
  46     INPUTS
  47         pat  - pattern to search for
  48         AP   - pointer to (initilized) AnchorPath structure
  49
  50     RESULT
  51         0     = success
  52         other = DOS error code
  53
  54     NOTES
  55
  56     EXAMPLE
  57
  58     BUGS
  59         Copying of the relative path to ap_Buf is not implemented yet
  60
  61     SEE ALSO
  62         MatchNext(), MatchEnd(), ParsePattern(), Examine(), CurrentDir()
  63         <dos/dosasl.h>
  64
  65     INTERNALS
  66
  67 *****************************************************************************/
  68 {
  69     AROS_LIBFUNC_INIT
  70     AROS_LIBBASE_EXT_DECL(struct DosLibrary *,DOSBase)
  71
  72     struct AChain * AC;
  73     struct AChain * AC_Prev = NULL;
  74     LONG PatLength;
  75     STRPTR ParsedPattern;
  76     BPTR firstlock;
  77
  78     bug("matchfirst\n");
  79
  80     if (!pat)
  81         return FALSE;
  82
  83     AP->ap_Base = NULL;
  84     AP->ap_Current = NULL;
  85
  86     PatLength = 2*strlen(pat)+2;
  87     ParsedPattern = AllocMem(PatLength, MEMF_ANY);
  88
  89
  90     if (NULL != ParsedPattern)
  91     {
  92         LONG PatStart = 0;
  93         LONG PatEnd   = 0;
  94         BOOL AllDone  = FALSE;
  95         LONG index;
  96         LONG success = FALSE;
  97         BPTR origdir;
  98
  99         bug("matchfirst: ParsedPattern mem okay. Calling ParsePatternNoCase\n");
 100
 101         /*
 102         ** Put the preparsed string to some memory
 103         ** If there are any wildcards then leave info
 104         */
 105         if (1 == ParsePatternNoCase(pat, ParsedPattern, PatLength))
 106           AP->ap_Flags |= (BYTE)APF_ITSWILD;
 107
 108         //bug("matchfirst: ParsePatternNoCase returned: pattern = \"%s\"\n", ParsedPattern);
 109
 110         /*
 111         ** First I search for the very first ':'. If a '/' comes along
 112         ** before that I quit. The string before and including the ':'
 113         ** is assumed to be an assigned directory, for example 'libs:'.
 114         ** So I will start looking for the pattern in that directory.
 115         */
 116         while (TRUE)
 117         {
 118             if (ParsedPattern[PatEnd] == ':')
 119             {
 120                 success = TRUE;
 121                 break;
 122             }
 123             else
 124             {
 125                 if ( ParsedPattern[PatEnd]         == '/'  ||
 126                      ParsedPattern[PatEnd]         == '\0' ||
 127                     (ParsedPattern[PatEnd] & 0x80) != 0
 128                                   /* a token or nonprintable letter */)
 129                 {
 130                     PatEnd = 0;
 131                     break;
 132                 }
 133             }
 134             PatEnd++;
 135         }
 136
 137         /*
 138         ** Only if success == TRUE an assigned dir was found.
 139         */
 140         if (TRUE == success)
 141         {
 142             /*
 143             ** try to create a lock to that assigned dir.
 144             */
 145             char Remember = ParsedPattern[PatEnd+1];
 146             PatEnd++;
 147             ParsedPattern[PatEnd] = '\0';
 148             firstlock = Lock(ParsedPattern, ACCESS_READ);
 149             origdir = CurrentDir(firstlock);
 150
 151             /*
 152             ** check whether an error occurred
 153             */
 154             if (NULL == firstlock)
 155             {
 156                 FreeMem(ParsedPattern, PatLength);
 157                 return IoErr(); // ERROR_DIR_NOT_FOUND; /* !!! hope that's the right error code... */
 158             }
 159
 160             /*
 161             ** I have the correct lock.
 162             */
 163             ParsedPattern[PatEnd] = Remember;
 164             PatStart=PatEnd;
 165
 166         } /* if (TRUE == success) */
 167         else
 168         {
 169             /*
 170             ** Create a lock to the current dir.
 171             */
 172             origdir   = CurrentDir(NULL);
 173             firstlock = DupLock(origdir);
 174             if (!firstlock)
 175             {
 176                 FreeMem(ParsedPattern, PatLength);
 177                 return IoErr();
 178             }
 179
 180             (void)CurrentDir(firstlock);
 181         }
 182
 183         bug("MatchFirst: origdir = %x\n", origdir);
 184         bug("MatchFirst: firstlock = %x\n", firstlock);
 185
 186         /*
 187         ** Allocate an AChain structure for the original directory.
 188         */
 189         AC = (struct AChain *)AllocVec(sizeof(struct AChain), MEMF_CLEAR);
 190         if (NULL == AC)
 191         {
 192             /*
 193             ** No more memory
 194             */
 195             FreeMem(ParsedPattern, PatLength);
 196             UnLock(firstlock);
 197             CurrentDir(origdir);
 198
 199             return ERROR_NO_FREE_STORE;
 200         }
 201
 202         AC->an_Lock  = origdir;
 203         AC->an_Flags = DDF_Completed|DDF_Single;
 204         AC_Prev     = AC;
 205
 206
 207         AP->ap_Base = AC;
 208
 209         /*
 210         ** Build the Anchor Chain. For every subdirectory I allocate
 211         ** an AChain structure and link them all together
 212         */
 213         while (FALSE == AllDone)
 214         {
 215             /*
 216             ** Search for the next '/' in the pattern and everything behind
 217             ** the previous '/' and before this '/' will go to an_String
 218             */
 219             while (TRUE)
 220             {
 221                 if (ParsedPattern[PatEnd] == '\0')
 222                 {
 223                     AllDone = TRUE;
 224                     PatEnd--;
 225                     break;
 226                 }
 227                 if (ParsedPattern[PatEnd] == '/')
 228                 {
 229                     PatEnd--;
 230                     break;
 231                 }
 232                 PatEnd++;
 233
 234             } /* while(TRUE) */
 235
 236             AC = AllocVec(sizeof(struct AChain)+(PatEnd-PatStart+2), MEMF_CLEAR);
 237             if (NULL == AC)
 238             {
 239                 /* not so bad if this was not the very first AC. */
 240                 if (NULL == AP->ap_Base)
 241                 {
 242                     /*
 243                     ** oops, it was the very first one. I really cannot do anything for
 244                     ** you. - sorry
 245                     */
 246                     FreeMem(ParsedPattern, PatLength);
 247
 248                     UnLock(AP->ap_Base->an_Lock);
 249                     CurrentDir(origdir); /* stegerg */
 250                     FreeMem(AP->ap_Base, sizeof(struct AChain));
 251
 252                     return ERROR_NO_FREE_STORE;
 253                 }
 254
 255                 /*
 256                 ** let me out of here. I will at least try to do something for you.
 257                 ** I can check the first few subdirs but that's gonna be it.
 258                 */
 259                 AP->ap_Flags |= APF_NOMEMERR;
 260                 break;
 261
 262             } /* if (NULL == AC) */
 263
 264             if (NULL == AP->ap_Base)
 265                 AP->ap_Base = AC;
 266
 267             if (NULL == AP->ap_Current)
 268                 AP->ap_Current = AC;
 269
 270
 271             if (NULL != AC_Prev)
 272                 AC_Prev->an_Child = AC;
 273
 274             AC->an_Parent = AC_Prev;
 275             AC_Prev       = AC;
 276
 277             /*
 278             ** copy the part of the pattern to the end of the AChain.
 279             */
 280             index = 0;
 281             while (PatStart <= PatEnd)
 282             {
 283                 AC->an_String[index] = ParsedPattern[PatStart];
 284                 index++;
 285                 PatStart++;
 286             }
 287
 288             /*
 289             ** Put PatStart and PetEnd behind the '/' that was found.
 290             */
 291             PatStart   = PatEnd + 2;
 292             PatEnd    += 2;
 293
 294             /*
 295             ** the trailing '\0' is there automatically as I allocated enough store
 296             ** with MEMF_CLEAR
 297             */
 298
 299         } /* while (FALSE == AllDone) */
 300
 301         /*
 302         ** Free the pattern since it has been distributed now
 303         */
 304         FreeMem(ParsedPattern, PatLength);
 305
 306         /*
 307         ** The AnchorChain to work with is the second one.
 308         */
 309         AP->ap_Base = AP->ap_Base->an_Child;
 310         AC          = AP->ap_Base;
 311
 312         AC->an_Lock = firstlock;
 313
 314         (void)Examine(AC->an_Lock, &AC->an_Info);
 315
 316         return followpattern(AP, AC, DOSBase);
 317
 318     } /* if (NULL != ParsedPattern) */
 319     else
 320     {
 321         return ERROR_NO_FREE_STORE;
 322     }
 323
 324     return 0;
 325
 326     AROS_LIBFUNC_EXIT
 327
 328 } /* MatchFirst */
 329
 330
 331
 332
 333
 334
 335 matchnext.c:
 336
 337
 338
 339
 340
 341
 342
 343 /*
 344     (C) 1995-96 AROS - The Amiga Research OS
 345     $Id$
 346
 347     Desc:
 348     Lang: english
 349 */
 350 #include <exec/memory.h>
 351 #include <exec/types.h>
 352 #include <dos/dos.h>
 353 #include <proto/exec.h>
 354 #include "dos_intern.h"
 355
 356 /*****************************************************************************
 357
 358     NAME */
 359 #include <dos/dosasl.h>
 360 #include <proto/dos.h>
 361
 362         AROS_LH1(LONG, MatchNext,
 363
 364 /*  SYNOPSIS */
 365         AROS_LHA(struct AnchorPath *, AP, D1),
 366
 367 /*  LOCATION */
 368         struct DosLibrary *, DOSBase, 138, Dos)
 369
 370 /*  FUNCTION
 371         Find next file or directory that matches a given pattern.
 372         See <dos/dosasl.h> for more docs and how to control MatchNext().
 373
 374
 375     INPUTS
 376         AP  - pointer to Anchor Path structure which had been passed to
 377               MatchFirst() before.
 378
 379     RESULT
 380
 381     NOTES
 382
 383     EXAMPLE
 384
 385     BUGS
 386         Copying of the relative path to ap_Buf is not implemented yet
 387
 388
 389     SEE ALSO
 390         MatchFirst() MatchEnd() CurrentDir() Examine() ExNext()
 391         ParsePattern() <dos/dosasl.h>
 392
 393     INTERNALS
 394
 395 *****************************************************************************/
 396 {
 397     AROS_LIBFUNC_INIT
 398     AROS_LIBBASE_EXT_DECL(struct DosLibrary *,DOSBase)
 399
 400     /*
 401     ** If the user says I am supposed to enter the directory then I first check
 402     ** whether it is a directory...
 403     */
 404
 405     struct AChain * AC = AP->ap_Current;
 406     BOOL success;
 407     struct Task * task = FindTask(NULL);
 408
 409     bug("matchnext\n");
 410
 411     AP->ap_BreakBits &= (SIGBREAKF_CTRL_C|
 412                          SIGBREAKF_CTRL_D|
 413                          SIGBREAKF_CTRL_E|
 414                          SIGBREAKF_CTRL_F);
 415
 416     if (0 != (AP->ap_Flags & APF_DODIR ))
 417     {
 418         bug("matchnext: APF_DODIR is set\n");
 419         if (AC->an_Info.fib_DirEntryType >= 0 /* &&
 420             AC->an_Info.fib_DirEntryType != ST_SOFTLINK */)
 421         {
 422             bug("matchnext: APF_DODIR is set. Is a directory.\n");
 423
 424             /* Ok, it seems to be a directory so I will enter it. */
 425             /* See whether there's a AnchorChain for that dir... */
 426             if (NULL == AC->an_Child)
 427             {
 428                 bug("matchnext: APF_DODIR is set. Is a directory. Has no child. Creating temp AChain\n");
 429                 AC->an_Child = (struct AChain *)
 430                     AllocVec(sizeof(struct AChain)+1, MEMF_CLEAR);
 431
 432                 if (AC->an_Child)
 433                 {
 434                     AC->an_Child->an_Parent = AC;
 435
 436                     AC->an_Child->an_String[0] = P_ANY;
 437                     AC->an_Child->an_Flags = DDF_PatternBit;
 438                 }
 439
 440                 bug("matchnext: Created temporary AChain structure: %x!\n", AC->an_Child);
 441             }
 442
 443             if (NULL != AC->an_Child)
 444             {
 445                 BPTR newdir;
 446
 447                 bug("matchnext: APF_DODIR is set. Is a directory. Has child.\n");
 448
 449                 /* Ok, we're all set. */
 450                 /* Lock the director by it's name. */
 451                 AP->ap_Current = AC->an_Child;
 452
 453                 bug("matchnext: APF_DODIR is set. Is a directory. Has child. Locking \"%s\"\n", AC->an_Info.fib_FileName);
 454
 455                 newdir = Lock(AC->an_Info.fib_FileName, ACCESS_READ);
 456                 bug("matchnext: APF_DODIR is set. Is a directory. Has child. Lock = %x\n", newdir);
 457
 458                 if (!newdir) /* stegerg */
 459                 {
 460                     AC = AC->an_Child;
 461                     return IoErr();
 462                 } /* end stegerg */
 463
 464                 //kprintf("CurrentDir()ing %x\n",AC->an_Info.fib_FileName);
 465                 (void)CurrentDir(newdir);
 466                 bug("matchnext: APF_DODIR is set. Is a directory. Has child. CurrentDir()ed to lock\n");
 467
 468                 AC = AC->an_Child;
 469                 AC->an_Lock = newdir;
 470                 bug("matchnext: APF_DODIR is set. Is a directory. Has child. Calling Examine\n");
 471                 Examine(AC->an_Lock, &AC->an_Info);
 472                 bug("matchnext: APF_DODIR is set. Is a directory. Has child. Called Examine\n");
 473             }
 474             else
 475             {
 476                 bug("matchnext: APF_DODIR is set. Could not alloc temp AChain. Returnin ERROR_NO_FREE_STORE\n");
 477                 return ERROR_NO_FREE_STORE;
 478             }
 479
 480         } /* if (AC->an_Info.fib_DirEntryType >= 0 ... */
 481
 482     } /* if (0 != (AP->ap_Flags & APF_DODIR )) */
 483
 484     AP->ap_Flags &= ~(BYTE)(APF_DODIR|APF_DIDDIR);
 485
 486     bug("matchnext 2\n");
 487
 488     /*
 489     ** AC points to the current AnchorChain
 490     */
 491     while (TRUE)
 492     {
 493         do
 494         {
 495             ULONG breakbits;
 496             /*
 497             ** Check for a break signal CTRL C/D/E/F
 498             */
 499             breakbits = (AP->ap_BreakBits & SetSignal(0, 0)); /* task->tc_SigRecvd */
 500
 501             if (0 != breakbits)
 502             {
 503                 /*
 504                 ** Finish right here... there might be a problem when/if the
 505                 ** algorithm is resumed the next time... Gotta test that.
 506                 */
 507                 AP->ap_FoundBreak = breakbits;
 508                 bug("matchnext 2: break bits were set. Returning ERROR_BREAK\n");
 509
 510                 return ERROR_BREAK;
 511             }
 512
 513             success = ExNext (AC->an_Lock, &AC->an_Info);
 514         }
 515
 516         while (DOSTRUE == success &&
 517                DOSFALSE == MatchPatternNoCase(AC->an_String,
 518                                               AC->an_Info.fib_FileName));
 519
 520
 521         if (DOSFALSE == success)
 522         {
 523             bug("matchnext 2: success == DOSFALSE (no matching file)\n");
 524             /*
 525             ** No more entries in this dir that match. So I might have to
 526             ** step back one directory. Unlock the current dir first.
 527             */
 528
 529       //kprintf("Couldn't find a matching file.!\n");
 530
 531             if (AP->ap_Base == AC)
 532             {
 533                 bug("matchnext 2: success == DOSFALSE (no matching file). Unlocking %x\n", AC->an_Lock);
 534                 UnLock(AC->an_Lock);
 535                 AP->ap_Current = AC->an_Parent;
 536                 bug("matchnext 2: success == DOSFALSE (no matching file). AP->ap_Current = %x\n", AP->ap_Current);
 537                 bug("matchnext 2: currentdiring to %x\n", AP->ap_Current->an_Lock);
 538                 CurrentDir(AP->ap_Current->an_Lock); /* stegerg */
 539                 bug("matchnext 2: Cannot step back dir. Returning ERROR_NO_MORE_ENTRIES\n");
 540                 return ERROR_NO_MORE_ENTRIES;
 541             }
 542
 543             /*
 544             ** Are there any previous directories???
 545             */
 546             if (NULL != AC && NULL != AC->an_Parent)
 547             {
 548                 LONG retval = 0;
 549
 550                 bug("matchnext 2: success == DOSFALSE. There is a Parent and AC is *not* NULL. Unlocking %x\n", AC->an_Lock);
 551
 552                 UnLock(AC->an_Lock);
 553                 AC->an_Lock = NULL;
 554
 555                 AC             = AC->an_Parent;
 556                 AP->ap_Current = AC;
 557
 558                 bug("matchnext 2: success == DOSFALSE. There is a Parent and AC is *not* NULL. CurrentDir()ing %x\n", AC->an_Lock);
 559
 560                 CurrentDir(AC->an_Lock);
 561
 562                 if (AC->an_Child->an_Flags & DDF_PatternBit)
 563                 {
 564                     FreeVec(AC->an_Child);
 565                     AC->an_Child = NULL;
 566                 }
 567                 else
 568                 if (0 == (AC->an_Flags & DDF_PatternBit))
 569                 {
 570                     /*
 571                     ** In this case I must silently follow the pattern again...
 572                     */
 573                     bug("matchnext 2: success == DOSFALSE. DDF_PatternBit is *not* set. Leaving matchnext with result from followpattern()\n");
 574                     return followpattern(AP, AC, DOSBase);
 575                 }
 576
 577                 AP->ap_Flags |= APF_DIDDIR;
 578                 /*
 579                 ** I show this dir again as I come back from searching it
 580                 */
 581
 582                 retval = createresult(AP, AC, DOSBase);
 583
 584                 /*
 585                 ** Step back to this directory and go on searching here
 586                 */
 587
 588                 CurrentDir(AC->an_Lock);
 589
 590                 if (NULL == AC->an_Parent)
 591                   retval = ERROR_NO_MORE_ENTRIES;
 592
 593                 bug("matchnext 2: returning retval\n", retval);
 594
 595                 return retval;
 596
 597             } /* if (NULL != AC->an_Parent && NULL != AC) */
 598
 599             bug("matchnext 2: success == DOSFALSE. There is no Parent and/or AC is NULL. Returning ERROR_NO_MORE_ENTRIES\n");
 600
 601             /*
 602             ** No previous directory, so I am done here...
 603             */
 604             return ERROR_NO_MORE_ENTRIES;
 605
 606         } /* if (DOSFALSE == success) */
 607         else
 608         {
 609             bug("matchnext 2: success == DOSTRUE (found a match). Leaving matchnext wth result from createresult()\n");
 610             /* Alright, I found a match... */
 611             return createresult(AP, AC, DOSBase);
 612         }
 613
 614     } /* while (TRUE) */
 615
 616     bug("matchnext 2: returning 0.\n");
 617
 618     return 0;
 619
 620     AROS_LIBFUNC_EXIT
 621
 622 } /* MatchNext */
 623
 624
 625
 626
 627
 628 matchend.c:
 629
 630
 631
 632
 633
 634
 635 /*
 636     (C) 1995-96 AROS - The Amiga Research OS
 637     $Id$
 638
 639     Desc:
 640     Lang: english
 641 */
 642 #include <proto/exec.h>
 643 #include "dos_intern.h"
 644
 645 /*****************************************************************************
 646
 647     NAME */
 648 #include <dos/dosasl.h>
 649 #include <proto/dos.h>
 650
 651         AROS_LH1(void, MatchEnd,
 652
 653 /*  SYNOPSIS */
 654         AROS_LHA(struct AnchorPath *, AP, D1),
 655
 656 /*  LOCATION */
 657         struct DosLibrary *, DOSBase, 139, Dos)
 658
 659 /*  FUNCTION
 660         Free the memory that was allocated by calls to MatchFirst() and
 661         MatchNext()
 662
 663     INPUTS
 664         AP  - pointer to Anchor Path structure which had been passed to
 665               MatchFirst() before.
 666
 667     RESULT
 668         Allocated memory is returned and filelocks are freed.
 669
 670     NOTES
 671
 672     EXAMPLE
 673
 674     BUGS
 675
 676     SEE ALSO
 677
 678     INTERNALS
 679
 680 *****************************************************************************/
 681 {
 682     AROS_LIBFUNC_INIT
 683     AROS_LIBBASE_EXT_DECL(struct DosLibrary *,DOSBase)
 684
 685     /* Free the AChain and unlock all locks that are still there */
 686     struct AChain * AC = AP->ap_Current;
 687     struct AChain * AC_tmp;
 688
 689     /* Unlock everything */
 690     if (NULL == AC)
 691         return;
 692
 693     while (NULL != AC->an_Parent)
 694     {
 695         bug("MatchEnd: unlocking %x\n", AC->an_Lock);
 696         UnLock(AC->an_Lock);
 697         AC = AC->an_Parent;
 698     }
 699
 700     bug("MatchEnd: CurrentDir(%x)\n", AC->an_Lock);
 701
 702     CurrentDir(AC->an_Lock);
 703
 704     /* AC points to the very first AChain obj. in the list */
 705     /* Free the AChain List */
 706     while (NULL != AC)
 707     {
 708         AC_tmp = AC->an_Child;
 709         FreeVec(AC);
 710         AC = AC_tmp;
 711     }
 712
 713     /* Cleanup AP */
 714     AP->ap_Base = NULL;
 715     AP->ap_Current = NULL;
 716
 717     AROS_LIBFUNC_EXIT
 718
 719 } /* MatchEnd */
 720
 721
 722
 723
 724
 725
 726
 727
 728
 729 match_misc.c:
 730
 731 #include <exec/types.h>
 732 #include <proto/exec.h>
 733 #include <proto/dos.h>
 734 #include <dos/dosasl.h>
 735 #include "dos_intern.h"
 736 #include <string.h>
 737
 738 LONG followpattern(struct AnchorPath * AP,
 739                    struct AChain * AC,
 740                    struct DosLibrary * DOSBase)
 741 {
 742     LONG success;
 743
 744     bug("followpattern start\n");
 745
 746     /*
 747     ** If the user specified the pattern libs:#?/s#/
 748     ** then I must enter that pattern before I return to the user.
 749     */
 750     while (TRUE)
 751     {
 752         do
 753         {
 754             success = ExNext (AC->an_Lock, &AC->an_Info);
 755         }
 756         while (DOSTRUE == success &&
 757                DOSFALSE == MatchPatternNoCase(AC->an_String,
 758                                               AC->an_Info.fib_FileName));
 759
 760         /*
 761         ** If no matching entry could be found here then I
 762         ** step back one directory, unless this is the very
 763         ** first directory already.
 764         */
 765         if (DOSFALSE == success)
 766         {
 767             bug("followpattern: success is DOSFALSE. Unlocking AC->an_Lock %x\n", AC->an_Lock);
 768             UnLock(AC->an_Lock);
 769             AC->an_Lock = NULL;
 770
 771             AC = AC->an_Parent;
 772             bug("followpattern: success is DOSFALSE. AC now %x\n", AC);
 773
 774             AP->ap_Current = AC;
 775
 776             bug("followpattern: success is DOSFALSE. CurrentDir()ing to %x\n", AC->an_Lock);
 777
 778             CurrentDir(AC->an_Lock);
 779
 780             bug("followpattern: success is DOSFALSE. AC has parent = %s\n", AC->an_Parent ? "yes" : "no");
 781
 782             if (NULL == AC->an_Parent)
 783             {
 784                 bug("followpattern: success is DOSFALSE. Has no parent. --> returning ERROR_NO_MORE_ENTRIES\n");
 785                 return ERROR_NO_MORE_ENTRIES;
 786             }
 787         }
 788         else
 789         {
 790             bug("followpattern: success *not* DOSFALSE.\n");
 791             if (AC->an_Info.fib_DirEntryType >= 0 /* &&
 792                 AC->an_Info.fib_DirEntryType != ST_SOFTLINK */)
 793             {
 794                 bug("followpattern: success *not* DOSFALSE. Is a directory.\n");
 795                 /*
 796                 ** I must silently enter this directory if there
 797                 ** are further patterns left, otherwise I return to the
 798                 ** user.
 799                 */
 800                 if (NULL != AC->an_Child)
 801                 {
 802                     /*
 803                     ** Silently entering this dir according to the
 804                     ** pattern.
 805                     */
 806                     BPTR newdir;
 807
 808                     bug("followpattern: success *not* DOSFALSE. Is a directory. Has a child. Entering\n");
 809
 810                     AP->ap_Current = AC->an_Child;
 811
 812                     bug("followpattern: success *not* DOSFALSE. Is a directory. Locking + CurrentDir()ing to %s\n", AC->an_Info.fib_FileName);
 813
 814                     newdir = Lock(AC->an_Info.fib_FileName, ACCESS_READ);
 815                     bug("followpattern: success *not* DOSFALSE. Is a directory. Locking done. Lock = %x\n", newdir);
 816                    (void)CurrentDir(newdir);
 817
 818                     bug("followpattern: success *not* DOSFALSE. Is a directory. CurrentDir()ing done\n");
 819
 820                     AC = AC->an_Child;
 821                     AC->an_Lock = newdir;
 822
 823                     bug("followpattern: success *not* DOSFALSE. Is a directory. Examining lock %x\n", newdir);
 824
 825                     Examine(AC->an_Lock, &AC->an_Info);
 826                     bug("followpattern: success *not* DOSFALSE. Is a directory. Examining lock done\n");
 827                 }
 828                 else
 829                 {
 830                     bug("followpattern: success *not* DOSFALSE. Is a directory. Has now child. Leaving followpattern with result from createresult\n");
 831                     /*
 832                     ** Ask the user whether to enter this dir or not
 833                     */
 834                     return createresult(AP, AC, DOSBase);
 835                 }
 836
 837             } /* is a directory */
 838             else
 839             {
 840                 /*
 841                 ** This is a file. If there is pattern left to match then
 842                 ** I must not show this file because I must fulfill the pattern
 843                 ** first.
 844                 */
 845                 if (NULL == AC->an_Child)
 846                 {
 847                     bug("followpattern: is a file and has no child: leaving followpattern with result from createresult \n");
 848
 849                     /*
 850                     ** There's no pattern left!
 851                     */
 852                     return createresult(AP, AC, DOSBase);
 853                 }
 854                 else
 855                     bug("followpattern: Silently skipping file %s!\n",AC->an_Info.fib_FileName);
 856
 857             } /* is a file */
 858
 859         } /* if (DOSFALSE == success) */
 860
 861     } /* while (TRUE) */
 862
 863 #if 0
 864     /*
 865     ** Hooray! A matching file was found. Also show the data in AP
 866     */
 867     createresult(AP, AC, DOSBase);
 868 #endif
 869
 870 }
 871
 872
 873 /*
 874 ** A file/directory has been found and now it must be written
 875 ** into the relevant structures.
 876 */
 877 LONG createresult(struct AnchorPath * AP,
 878                   struct AChain * AC,
 879                   struct DosLibrary * DOSBase)
 880 {
 881     bug("createresult\n");
 882
 883     CopyMem(&AC->an_Info, &AP->ap_Info, sizeof(struct FileInfoBlock));
 884     if (0 != AP->ap_Strlen)
 885     {
 886         if (FALSE == writeFullPath(AP))
 887         {
 888             bug("createresult: returning ERROR_BUFFER_OVERFLOW\n");
 889             return ERROR_BUFFER_OVERFLOW;
 890         }
 891     }
 892
 893     bug("createresult: done\n");
 894
 895     return 0;
 896 }
 897
 898
 899 /* Function needed by MatchFirst/Next */
 900
 901 BOOL writeFullPath(struct AnchorPath * AP)
 902 {
 903     struct AChain * AC = AP->ap_Base;
 904     BOOL end = FALSE;
 905     char * LastPos = (char *)&AP->ap_Buf;
 906     int copied = 0;
 907
 908     bug("writefullpath\n");
 909     while (FALSE == end)
 910     {
 911         int len = strlen(AC->an_Info.fib_FileName);
 912         if (copied+len > AP->ap_Strlen)
 913         {
 914             bug("writefullpath: not enough space\n");
 915             return FALSE;
 916         }
 917         strcpy(&LastPos[copied], AC->an_Info.fib_FileName);
 918         copied += len;
 919
 920         if (AC != AP->ap_Current)
 921         {
 922             /* also add a '/' */
 923             if (copied+1 > AP->ap_Strlen)
 924             {
 925                 bug("writefullpath: not enough space 2\n");
 926                 return FALSE;
 927             }
 928             LastPos[copied]='/';
 929             copied++;
 930         }
 931         else
 932         {
 933             if (copied+1 > AP->ap_Strlen)
 934             {
 935                 bug("writefullpath: not enough space 3\n");
 936                 return FALSE;
 937             }
 938             LastPos[copied]='\0';
 939             end = TRUE;
 940         }
 941
 942         AC = AC->an_Child;
 943     }
 944
 945     bug("writefullpath: done\n");
 946
 947     return TRUE;
 948 }