test/newmatch.c

   1 #include <exec/exec.h>
   2 #include <dos/dos.h>
   3 #include <dos/dosextens.h>
   4 #include <dos/dosasl.h>
   5 #include <proto/exec.h>
   6 #include <proto/dos.h>
   7
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <stdlib.h>
  11
  12 /****************************************************************************************/
  13
  14 #define MATCHFUNCS_NO_DUPLOCK   0
  15
  16 /****************************************************************************************/
  17
  18 #define COMPTYPE_NORMAL  1
  19 #define COMPTYPE_PATTERN 2
  20 #define COMPTYPE_UNKNOWN 3
  21
  22 /****************************************************************************************/
  23
  24 LONG My_MatchNext(struct AnchorPath *AP);
  25
  26 /****************************************************************************************/
  27
  28
  29 static void showacflags(struct AChain *ac)
  30 {
  31     BYTE flags = ac->an_Flags;
  32
  33     printf("(");
  34
  35     if (flags & DDF_PatternBit)
  36     {
  37         flags &= ~DDF_PatternBit;
  38         printf("DDF_PatternBit ");
  39     }
  40
  41     if (flags & DDF_ExaminedBit)
  42     {
  43         flags &= ~DDF_ExaminedBit;
  44         printf("DDF_ExaminedBit ");
  45     }
  46
  47     if (flags & DDF_Completed)
  48     {
  49         flags &= ~DDF_Completed;
  50         printf("DDF_Completed ");
  51     }
  52
  53     if (flags & DDF_AllBit)
  54     {
  55         flags &= ~DDF_AllBit;
  56         printf("DDF_All ");
  57     }
  58
  59     if (flags & DDF_Single)
  60     {
  61          flags &= ~DDF_Single;
  62          printf("DDF_Single ");
  63     }
  64
  65     if (flags)
  66     {
  67          printf("UNKNOWN = %8x ", flags);
  68     }
  69
  70     printf(")");
  71 }
  72
  73 static void showaclist(struct AChain *ac)
  74 {
  75     while(ac)
  76     {
  77         printf("achain: address = %p flags = %x ", ac, ac->an_Flags);
  78         showacflags(ac);
  79         printf(" string=\"%s\"\n", ac->an_String);
  80         ac = ac->an_Child;
  81     }
  82
  83 }
  84
  85 /****************************************************************************************/
  86
  87 static void RemoveTrailingSlash(STRPTR s)
  88 {
  89     LONG len = strlen(s);
  90
  91     if (len >= 2)
  92     {
  93         if ((s[len - 1] == '/') &&
  94             (s[len - 2] != '/'))
  95         {
  96             s[len - 1] = '\0';
  97         }
  98     }
  99 }
 100
 101 /****************************************************************************************/
 102
 103 static struct AChain *Match_AllocAChain(LONG extrasize, struct DosLibrary *DOSBase)
 104 {
 105     return AllocVec(sizeof(struct AChain) + extrasize, MEMF_PUBLIC | MEMF_CLEAR);
 106 }
 107
 108 /****************************************************************************************/
 109
 110 static void Match_FreeAChain(struct AChain *ac, struct DosLibrary *DOSBase)
 111 {
 112     if (ac)
 113     {
 114         FreeVec(ac);
 115     }
 116 }
 117
 118 /*****************************************************************************************
 119
 120 The job of BuildAChainList is to split the pattern string passed to MatchFirst into
 121 path components. Most imporant rules (as found out after hours of testing on Amiga):
 122
 123   - Each path component containing a pattern string is put into a single AChain
 124   - If there are several successive path components *without* pattern then this
 125     are merged into one single AChain.
 126   - No matter what: the last path component always gets into its own single AChain.
 127
 128 Examples: [<???>] is one AChain
 129
 130   pictures                          [pictures]
 131   pictures/#?                       [pictures} [#?]
 132   work:                             [work:] []
 133   work:pictures                     [work:} [pictures]
 134   work:pictures/#?                  [work:pictures] [#?]
 135   work:pictures/aros                [work:pictures] [aros]
 136   work:pictures/aros/games          [work:pictures/aros] [games]
 137   work:#?/aros/games                [work:] [#?] [aros] [games}
 138   work:#?/#?/aros/games/quake       [work:} [#?] [#?] [aros/games] [quake]
 139
 140 *****************************************************************************************/
 141
 142 static LONG BuildAChainList(STRPTR pattern, struct AnchorPath *AP,
 143                             struct AChain **retac, struct DosLibrary *DOSBase)
 144 {
 145     struct AChain       *baseac = 0, *prevac = 0, *ac;
 146     STRPTR              patterncopy = 0;
 147     STRPTR              patternstart, patternend, patternpos;
 148     LONG                len, error = 0;
 149     WORD                comptype = COMPTYPE_UNKNOWN;
 150     WORD                compcount = 0;
 151     WORD                i;
 152     UBYTE               c;
 153
 154     *retac = 0;
 155
 156     len = strlen(pattern);
 157
 158     patterncopy = AllocVec(len + 1, MEMF_PUBLIC);
 159     if (!patterncopy)
 160     {
 161         error = ERROR_NO_FREE_STORE;
 162         goto done;
 163     }
 164
 165     strcpy(patterncopy, pattern);
 166
 167     RemoveTrailingSlash(patterncopy);
 168
 169     patternstart = patterncopy;
 170
 171     patternpos = strchr(patterncopy, ':');
 172     if (!patternpos)
 173     {
 174         comptype = COMPTYPE_UNKNOWN;
 175         patternpos = patternstart;
 176         patternend = patternstart;
 177     }
 178     else
 179     {
 180         comptype = COMPTYPE_NORMAL;
 181         patternend = patternpos++;
 182         compcount = 1;
 183     }
 184
 185     do
 186     {
 187         for(;;)
 188         {
 189             c = *patternpos;
 190             if (c == '/')
 191             {
 192                 if (comptype == COMPTYPE_UNKNOWN)
 193                 {
 194                     comptype = COMPTYPE_NORMAL;
 195                     patternend = patternpos;
 196                 }
 197                 else if (comptype == COMPTYPE_NORMAL)
 198                 {
 199                     patternend = patternpos;
 200                     compcount++;
 201                 }
 202                 if (comptype == COMPTYPE_PATTERN)
 203                 {
 204                     patternend = patternpos;
 205                     break;
 206                 }
 207             }
 208             else if (c == '\0')
 209             {
 210                 if (comptype == COMPTYPE_UNKNOWN)
 211                 {
 212                     comptype = COMPTYPE_NORMAL;
 213                     patternend = patternpos;
 214                     break;
 215                 }
 216                 if (comptype == COMPTYPE_NORMAL)
 217                 {
 218                     compcount++;
 219                     break;
 220                 }
 221                 patternend = patternpos;
 222                 break;
 223             }
 224             else if ((c == '#') ||
 225                      (c == '~') ||
 226                      (c == '[') ||
 227                      (c == ']') ||
 228                      (c == '?') ||
 229                      (c == '*') ||
 230                      (c == '(') ||
 231                      (c == ')') ||
 232                      (c == '|') ||
 233                      (c == '%'))
 234             {
 235                 if (comptype == COMPTYPE_NORMAL)
 236                 {
 237                     break;
 238                 }
 239                 comptype = COMPTYPE_PATTERN;
 240             }
 241
 242             patternpos++;
 243
 244         } /* for(;;) */
 245
 246         len = (LONG)(patternend - patternstart + 2);
 247         if (comptype == COMPTYPE_PATTERN) len = len * 2 + 2;
 248
 249         ac = Match_AllocAChain(len, DOSBase);
 250         if (!ac)
 251         {
 252             error = ERROR_NO_FREE_STORE;
 253             goto done;
 254         }
 255
 256         if (comptype == COMPTYPE_NORMAL)
 257         {
 258             if (*patternend == '\0')
 259             {
 260                 strcpy(ac->an_String, patternstart);
 261             } else {
 262                 c = patternend[1];
 263                 patternend[1] = '\0';
 264                 strcpy(ac->an_String, patternstart);
 265                 patternend[1] = c;
 266             }
 267
 268         } /* if (comptype == COMPTYPE_NORMAL) */
 269         else
 270         {
 271             if (*patternend == '\0')
 272             {
 273                 i = ParsePatternNoCase(patternstart, ac->an_String, len);
 274             }
 275             else
 276             {
 277                 c = patternend[1];
 278                 patternend[1] = '\0';
 279                 i = ParsePatternNoCase(patternstart, ac->an_String, len);
 280                 patternend[1] = c;
 281             }
 282
 283             if (i == -1)
 284             {
 285                 error = ERROR_BAD_TEMPLATE;
 286                 Match_FreeAChain(ac, DOSBase);ac = 0;
 287                 goto done;
 288             }
 289
 290             if (i)
 291             {
 292                 ac->an_Flags |= DDF_PatternBit;
 293                 AP->ap_Flags |= APF_ITSWILD;
 294             }
 295
 296         } /* if (comptype == COMPTYPE_NORMAL) else ... */
 297
 298         RemoveTrailingSlash(ac->an_String);
 299
 300         if (!prevac)
 301         {
 302             baseac = ac;
 303         }
 304         else
 305         {
 306             prevac->an_Child = ac;
 307             ac->an_Parent = prevac;
 308         }
 309
 310         prevac = ac;
 311
 312         patternpos = patternend;
 313         comptype = COMPTYPE_UNKNOWN;
 314         patternstart = patternend = patternpos + 1;
 315         compcount = 0;
 316
 317     } while (*patternpos++ != '\0');
 318
 319 done:
 320     if (patterncopy) FreeVec(patterncopy);
 321
 322     if (!error)
 323     {
 324 #if MATCHFUNCS_NO_DUPLOCK
 325         /*
 326         ** No DupLock() here, because then we would have to UnLock it in MatchEnd
 327         ** and we would not know any valid lock to which we could CurrentDir after,
 328         ** because we must make sure there is a valid CurrentDir after MatchEnd.
 329         */
 330
 331         baseac->an_Lock = CurrentDir(0);
 332         CurrentDir(baseac->an_Lock);
 333 #endif
 334         *retac = baseac;
 335     }
 336     else
 337     {
 338         AP->ap_Flags |= APF_NOMEMERR;
 339
 340         if (baseac)
 341         {
 342             #define nextac prevac /* to not have to add another variable */
 343
 344             ac = baseac;
 345             while(ac)
 346             {
 347                 nextac = ac->an_Child;
 348                 Match_FreeAChain(ac, DOSBase);
 349                 ac = nextac;
 350             }
 351         }
 352     }
 353
 354     return error;
 355 }
 356
 357 /****************************************************************************************/
 358
 359 static LONG Match_MakeResult(struct AnchorPath *AP, struct DosLibrary *DOSBase)
 360 {
 361     LONG error = 0;
 362
 363     AP->ap_Info = AP->ap_Current->an_Info;
 364     if (AP->ap_Strlen)
 365     {
 366         AP->ap_Buf[0] = 0;
 367         if (NameFromLock(AP->ap_Current->an_Lock, AP->ap_Buf, AP->ap_Strlen))
 368         {
 369             if (!AddPart(AP->ap_Buf, AP->ap_Current->an_Info.fib_FileName, AP->ap_Strlen))
 370             {
 371                 error = IoErr();
 372             }
 373         } else {
 374             error = IoErr();
 375         }
 376     }
 377
 378     return error;
 379 }
 380
 381 /****************************************************************************************/
 382
 383 LONG My_MatchFirst(STRPTR pat, struct AnchorPath *AP)
 384 {
 385     struct AChain       *ac;
 386     LONG                error;
 387
 388     AP->ap_Flags = 0;
 389     AP->ap_Base = 0;
 390     AP->ap_Current = 0;
 391
 392     error = BuildAChainList(pat, AP, &ac, DOSBase);
 393     if (error == 0)
 394     {
 395         AP->ap_Base = AP->ap_Current = ac;
 396
 397         error = My_MatchNext(AP);
 398
 399     } /* if (error == 0) */
 400
 401     printf("My_MatchFirst: returning %ld. Ac = %p\n", (long)error, ac);
 402
 403     SetIoErr(error);
 404
 405     return error;
 406 }
 407
 408 /****************************************************************************************/
 409
 410 LONG My_MatchNext(struct AnchorPath *AP)
 411 {
 412     struct AChain       *ac = AP->ap_Current;
 413     BPTR                origdir, old_current_lock;
 414     LONG                error = 0;
 415
 416     origdir = CurrentDir(0);
 417     CurrentDir(origdir);
 418
 419     old_current_lock = ac->an_Lock;
 420
 421     AP->ap_Flags &= ~APF_DIDDIR;
 422
 423     /*
 424     ** Check if we are asked to enter a directory, but only do this
 425     ** if it is really possible
 426     */
 427
 428     if ((AP->ap_Flags & APF_DODIR) &&
 429         (ac->an_Flags & DDF_ExaminedBit) &&
 430         (ac->an_Info.fib_DirEntryType > 0) &&
 431         (ac->an_Child == NULL))
 432     {
 433         /*
 434         ** Alloc a new AChain. Make it the active one. Set its string to "#?" and
 435         ** mark it with DDF_AllBit Flag to indicate that this is a "APF_DODIR-AChain".
 436         ** This is important for "back steppings", because "APF_DODIR-AChains" must
 437         ** be removed and freed then and the user must be notified about the leaving
 438         ** of a APF_DODIR-AChain with APF_DIDDIR.
 439         */
 440
 441         if ((ac->an_Child = Match_AllocAChain(1, DOSBase)))
 442         {
 443             ac->an_Child->an_Parent = ac;
 444             ac = ac->an_Child;
 445             AP->ap_Current = ac;
 446
 447             ac->an_String[0] = P_ANY;
 448             ac->an_String[1] = 0;
 449             ac->an_Flags = DDF_PatternBit | DDF_AllBit;
 450         }
 451
 452         /*
 453         ** If the allocation did not work, we simple ignore APF_DODIR. Just like if
 454         ** the user did not set this flag. Good idea or bad idea?
 455         */
 456     }
 457
 458
 459     /* Main loop for AChain traversing */
 460
 461     for(;;)
 462     {
 463         BOOL must_go_back = FALSE;
 464
 465         /* Check for user breaks (CTRL_C, ...) */
 466
 467         if (AP->ap_BreakBits)
 468         {
 469             AP->ap_FoundBreak = CheckSignal(AP->ap_BreakBits);
 470             if (AP->ap_FoundBreak)
 471             {
 472                 error = ERROR_BREAK;
 473                 goto done;
 474             }
 475         }
 476
 477         /* Check if AChain must be "setup" */
 478
 479         if (!(ac->an_Flags & DDF_ExaminedBit))
 480         {
 481             /*
 482             ** This AChain must be "setup". First AChain->an_Lock must point
 483             ** to the parent directory, that is the directory where this
 484             ** AChain is "in". !
 485             */
 486
 487             if (ac->an_Parent)
 488             {
 489                 CurrentDir(ac->an_Parent->an_Lock);
 490                 ac->an_Lock = Lock(ac->an_Parent->an_Info.fib_FileName, SHARED_LOCK);
 491
 492                 if (!ac->an_Lock)
 493                 {
 494                     error = IoErr();
 495                     goto done;
 496                 }
 497
 498             }
 499 #if !MATCHFUNCS_NO_DUPLOCK
 500             else
 501             {
 502                 ac->an_Lock = DupLock(origdir);
 503                 if (!ac->an_Lock)
 504                 {
 505                     error = IoErr();
 506                     goto done;
 507                 }
 508             }
 509 #else
 510             /*
 511             ** If there was no ac->an_Parent then we are dealing with the
 512             ** first AChain whose lock was already setup in BuildAChainList
 513             */
 514 #endif
 515             CurrentDir(ac->an_Lock);
 516
 517             if (ac->an_Flags & DDF_PatternBit)
 518             {
 519                 /*
 520                 ** If this is a pattern AChain we first Examine here our
 521                 ** parent directory, so that it then can be traversed with
 522                 ** ExNext
 523                 */
 524
 525                 if (!Examine(ac->an_Lock, &ac->an_Info))
 526                 {
 527                     error = IoErr();
 528                     goto done;
 529                 }
 530                 ac->an_Flags |= DDF_ExaminedBit;
 531
 532             } /* if (ac->an_Flags & DDF_PatternBit) */
 533             else
 534             {
 535                 BPTR lock;
 536                 LONG success;
 537
 538                 /*
 539                 ** This is a normal AChain (no pattern). Try to lock it
 540                 ** to see if it exists.
 541                 */
 542
 543                 if (!(lock = Lock(ac->an_String, SHARED_LOCK)))
 544                 {
 545                     /* It does not exist, so if possible go back one step */
 546
 547                     if (ac->an_Parent)
 548                     {
 549                         /* [2] */
 550
 551                         must_go_back = TRUE;
 552                     }
 553                     else
 554                     {
 555                         /* if going back is not possible get error code and exit */
 556                         error = IoErr();
 557                         goto done;
 558                     }
 559
 560                 } /* if (!(lock = Lock(ac->an_String, SHARED_LOCK))) */
 561                 else
 562                 {
 563                     /* The File/Direcory ac->an_String exists */
 564
 565                     success = Examine(lock, &ac->an_Info);
 566                     UnLock(lock);
 567
 568                     if (!success)
 569                     {
 570                         /*
 571                         ** Examine()ing the file/directory did not
 572                         ** work, although the lock was successful!?.
 573                         ** Get error code and exit
 574                         */
 575
 576                         error = IoErr();
 577                         goto done;
 578                     }
 579
 580                     /*
 581                     ** This strcpy is necessary, because in case
 582                     ** of empty ac->an_String("") fib_FileName would
 583                     ** get parent directory name which it must not!
 584                     */
 585
 586                     strcpy(ac->an_Info.fib_FileName, ac->an_String);
 587
 588                     ac->an_Flags |= DDF_ExaminedBit;
 589
 590                     /*
 591                     ** If this is a file, but there are still more path components to
 592                     ** follow then we have to go back one step (AChain)
 593                     */
 594
 595                     if (ac->an_Child && (ac->an_Info.fib_DirEntryType < 0))
 596                     {
 597                         /* [1] */
 598
 599                         must_go_back = TRUE;
 600                     }
 601
 602                     /*
 603                     ** Here we either have found a matching file/directory (result)
 604                     ** or, if ac->an_Child != NULL we have still to continue walking
 605                     ** through the AChains until we are in the last one. This all
 606                     ** happens further below
 607                     */
 608
 609                 } /* if (!(lock = Lock(ac->an_String, SHARED_LOCK))) else ... */
 610
 611             } /* if (ac->an_Flags & DDF_PatternBit) else ... */
 612
 613         } /* if (!(ac->an_Flags & DDF_ExaminedBit)) */
 614         else
 615         {
 616             /*
 617             ** This AChain was already setup.
 618             **
 619             ** When an AChain which is *not* a pattern already had DDF_PatternBit
 620             ** set, then this means ERROR_NO_MORE_ENTRIES, so we try to go back
 621             ** one step
 622             */
 623
 624             if (!(ac->an_Flags & DDF_PatternBit))
 625             {
 626                 /* [4] */
 627
 628                 must_go_back = TRUE;
 629             }
 630         }
 631
 632         /*
 633         ** Here we can be sure that the actual AChain is setup, ie: it will
 634         ** have ac->an_Lock set correctly and to indicate this DDF_ExaminedBit
 635         ** was set
 636         */
 637
 638         CurrentDir(ac->an_Lock);
 639
 640         if (ac->an_Flags & DDF_PatternBit)
 641         {
 642             if(ExNext(ac->an_Lock, &ac->an_Info))
 643             {
 644                 if (MatchPatternNoCase(ac->an_String, ac->an_Info.fib_FileName))
 645                 {
 646                     /*
 647                     ** This file matches the pattern in ac->an_String. If there
 648                     ** are no more AChains to follow then we have found a matching
 649                     ** file/directory (a result)  --> break.
 650                     */
 651
 652                     if (!ac->an_Child) break;
 653
 654                 } else {
 655                     /* Did not match. Go to top of "for(;;)" loop */
 656                     continue;
 657                 }
 658             }
 659             else
 660             {
 661                 error = IoErr();
 662                 if (error != ERROR_NO_MORE_ENTRIES) goto done;
 663
 664                 /* [3] */
 665
 666                 must_go_back = TRUE;
 667             }
 668
 669         } /* if (ac->an_Flags & DDF_PatternBit) */
 670
 671         /*
 672         ** Handle the cases where we must (try to) go back to the previous AChain.
 673         ** This can happen if the actual AChain turned out to be a file although
 674         ** there are still more AChains to follow [1]. Or if the actual AChain did not
 675         ** exist at all [2]. Or if in a pattern AChain ExNext() told us that there are
 676         ** no more entries [3]. Or if we were getting to a normal (no pattern) AChain
 677         ** which was already setup (DDF_ExaminedBit) [4].
 678         */
 679
 680         if (must_go_back)
 681         {
 682             /* Check if going back is possible at all */
 683
 684             if (!ac->an_Parent)
 685             {
 686                 error = ERROR_NO_MORE_ENTRIES;
 687                 goto done;
 688             }
 689
 690             /* Yep. It is possible. So let's cleanup the AChain. */
 691
 692             CurrentDir(ac->an_Parent->an_Lock);
 693
 694             UnLock(ac->an_Lock);
 695
 696             ac->an_Lock = BNULL;
 697             ac->an_Flags &= ~DDF_ExaminedBit;
 698
 699             /* Make ac and AP->ap_Current point to the previous AChain */
 700
 701             AP->ap_Current = ac->an_Parent;
 702
 703             /*
 704             ** If this was an APF_DODIR Achain (indicated by DDF_AllBit)
 705             ** then the AChain must be unlinked and freed. And the user
 706             ** must be informed about the leaving with APF_DIDDIR and
 707             ** a "result" in AnchorPath which points to the directory which
 708             ** was leaved.
 709             */
 710
 711             if (ac->an_Flags & DDF_AllBit)
 712             {
 713                 AP->ap_Current->an_Child = NULL;
 714                 Match_FreeAChain(ac, DOSBase);
 715                 AP->ap_Flags |= APF_DIDDIR;
 716
 717                 /* go out of for(;;) loop --> MakeResult */
 718
 719                 break;
 720             }
 721
 722             ac = AP->ap_Current;
 723
 724         } /* if (must_go_back) */
 725         else
 726         {
 727             if (!ac->an_Child)
 728             {
 729                 /*
 730                 ** We have reached the last AChain. And this means that
 731                 ** we have found a matching file/directory :-)). Go out of
 732                 ** for(;;) loop --> MakeResult
 733                 */
 734
 735                 break;
 736             }
 737
 738             ac = ac->an_Child;
 739             AP->ap_Current = ac;
 740         }
 741
 742     } /* for(;;) */
 743
 744     error = Match_MakeResult(AP, DOSBase);
 745
 746 done:
 747     CurrentDir(origdir);
 748
 749     AP->ap_Flags &= ~APF_DODIR;
 750
 751     if (old_current_lock != AP->ap_Current->an_Lock)
 752     {
 753         AP->ap_Flags |= APF_DirChanged;
 754     }
 755     else
 756     {
 757         AP->ap_Flags &= ~APF_DirChanged;
 758     }
 759
 760     SetIoErr(error);
 761
 762     return error;
 763
 764 }
 765
 766 /****************************************************************************************/
 767
 768 void My_MatchEnd(struct AnchorPath *AP)
 769 {
 770     struct AChain *ac = AP->ap_Base, *acnext;
 771
 772     if (ac)
 773     {
 774
 775 #if MATCHFUNCS_NO_DUPLOCK
 776         /*
 777         ** CurrentDir to a valid lock, ie. one that will not be
 778         ** killed further below
 779         */
 780
 781         CurrentDir(ac->an_Lock);
 782 #endif
 783         while(ac)
 784         {
 785             acnext = ac->an_Child;
 786
 787             /*
 788             ** Dont unlock lock in first AChain because it is the same
 789             ** as the current directory when MatchFirst was called. And
 790             ** this lock was not DupLock()ed!!!
 791             */
 792
 793             if (ac->an_Lock
 794 #if MATCHFUNCS_NO_DUPLOCK
 795                 && (ac != AP->ap_Base)
 796 #endif
 797                 )
 798             {
 799                 UnLock(ac->an_Lock);
 800             }
 801
 802             Match_FreeAChain(ac, DOSBase);
 803
 804             ac = acnext;
 805         }
 806     }
 807
 808     AP->ap_Current = NULL;
 809     AP->ap_Base = NULL;
 810 }
 811
 812 /****************************************************************************************/
 813
 814 #define ARG_TEMPLATE "FILE/A,ALL/S"
 815 #define ARG_FILE 0
 816 #define ARG_ALL  1
 817 #define NUM_ARGS 2
 818
 819 /****************************************************************************************/
 820
 821 static char s[300];
 822 static char *filename;
 823 static BOOL all;
 824 static struct RDArgs *myargs;
 825 static IPTR args[NUM_ARGS];
 826
 827 /****************************************************************************************/
 828
 829 static void cleanup(char *msg)
 830 {
 831     if (msg) printf("newmatch: %s\n", msg);
 832
 833     if (myargs) FreeArgs(myargs);
 834
 835     exit(0);
 836 }
 837
 838 /****************************************************************************************/
 839
 840 static void doserror(void)
 841 {
 842     Fault(IoErr(), 0, s, 255);
 843     cleanup(s);
 844 }
 845
 846 /****************************************************************************************/
 847
 848 static void getarguments(void)
 849 {
 850     if (!(myargs = ReadArgs(ARG_TEMPLATE, args, 0)))
 851     {
 852         doserror();
 853     }
 854
 855     filename = (char *)args[ARG_FILE];
 856     all = args[ARG_ALL] ? TRUE : FALSE;
 857 }
 858
 859 /****************************************************************************************/
 860
 861 static void my_matchme(char *pattern, BOOL all)
 862 {
 863     struct AnchorPath stackap[2], *AP;
 864     LONG error = 0;
 865
 866     AP = (struct AnchorPath *)((((IPTR)stackap) + 3) & ~3);
 867
 868     memset(AP, 0, sizeof(struct AnchorPath));
 869
 870     error =  My_MatchFirst(pattern, AP);
 871
 872     if (error != 0)
 873     {
 874         printf("MatchFirst: error = %d\n", (int)error);
 875     }
 876     else
 877     {
 878         printf("direntrytype = %d\n", (int)AP->ap_Info.fib_DirEntryType);
 879         if (!(AP->ap_Flags & APF_ITSWILD) &&
 880              (AP->ap_Info.fib_DirEntryType > 0))
 881         {
 882              /* pattern was an explicitely named directory */
 883              AP->ap_Flags |= APF_DODIR;
 884         }
 885
 886         printf("ap_Flags = %x\n", AP->ap_Flags);
 887         NameFromLock(AP->ap_Current->an_Lock, s, 300);
 888         printf("BaseLock = \"%s\"\n", s);
 889
 890         showaclist(AP->ap_Base);
 891
 892         while(error == 0)
 893         {
 894             if (AP->ap_Flags & APF_DIDDIR)
 895             {
 896                 printf("DIDDIR: ");
 897             } else {
 898                 if (all && (AP->ap_Info.fib_DirEntryType > 0))
 899                 {
 900                     AP->ap_Flags |= APF_DODIR;
 901                     printf("DOING DIR: ");
 902                 }
 903             }
 904             printf("fib_FileName = \"%s\"\n", AP->ap_Info.fib_FileName);
 905
 906             error = My_MatchNext(AP);
 907         }
 908
 909     }
 910
 911     My_MatchEnd(AP);
 912
 913 }
 914
 915 /****************************************************************************************/
 916 /****************************************************************************************/
 917
 918 int main(void)
 919 {
 920     getarguments();
 921     my_matchme(filename, all);
 922     cleanup(0);
 923     return 0;
 924 }
 925
 926 /****************************************************************************************/