rom/dos/match_old.c

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