test/matchtest.c

   1 /* Test of the DOS functions MatchFirst MatchNext and MatchEnd.
   2  */
   3
   4 #include <proto/dos.h>
   5 #include <proto/exec.h>
   6 #include <dos/dos.h>
   7 #include <dos/dosasl.h>
   8 #include <exec/types.h>
   9 #include <exec/memory.h>
  10
  11 #include <stdio.h>
  12 #include <string.h>
  13
  14
  15 /*
  16    Uncomment the following defines and function prototypes
  17    if you want to use the code for the Match*-functions that
  18    is in this file.
  19 */
  20
  21 /*
  22 #undef MatchFirst
  23 #undef MatchNext
  24 #undef MatchEnd
  25 #define MatchFirst MyMatchFirst
  26 #define MatchNext  MyMatchNext
  27 #define MatchEnd   MyMatchEnd
  28   LONG MyMatchFirst(STRPTR pat, struct AnchorPath * AP);
  29   LONG MyMatchNext(struct AnchorPath *AP);
  30   void MyMatchEnd(struct AnchorPath *AP);
  31 */
  32
  33   BOOL writeFullPath(struct AnchorPath *AP);
  34
  35 int main (void)
  36 {
  37   BOOL error;
  38   int strlength=160;
  39   struct AnchorPath * AP = AllocVec(sizeof(struct AnchorPath) + strlength,MEMF_CLEAR);
  40   char * Pattern = AllocVec(80,MEMF_ANY);
  41
  42   //dirlock = Lock("sys:",ACCESS_READ);
  43   //oldlock = CurrentDir(dirlock);
  44
  45   AP->ap_BreakBits = SIGBREAKF_CTRL_C;
  46   AP->ap_Flags  = 0;//APF_DODIR;
  47   AP->ap_Strlen = strlength;
  48
  49   printf("Give me a pattern to serach for: ");
  50   /* the following line breaks AROS in MatchEnd() when calling FreeVec()
  51      the second time the program is run. I have no idea why, though. */
  52   scanf("%s",Pattern);
  53   printf("Pattern to search for: %s\n",Pattern);
  54
  55   for(error = MatchFirst(Pattern,AP); error == 0;
  56       error = MatchNext(AP))
  57   {
  58     if (AP->ap_Flags & APF_DIDDIR)
  59     {
  60       AP->ap_Flags &= ~APF_DIDDIR;
  61       printf(" leaving \033[32m%s\033[39m\n",AP->ap_Buf);
  62     }
  63     else /* if dir then enter it! */
  64     {
  65       if (AP->ap_Info.fib_DirEntryType >= 0)
  66       {
  67         AP->ap_Flags |=APF_DODIR;
  68         printf("entering \033[33m%s\033[39m\n",AP->ap_Buf);
  69       }
  70       else
  71       {
  72         //BPTR fl = CurrentDir(AP->ap_Current->an_Lock);
  73         //(void)CurrentDir(fl);
  74
  75         printf("         %s\n",AP->ap_Buf);
  76       }
  77     }
  78   }
  79   printf("error = %i \n",error);
  80   MatchEnd(AP);
  81   FreeVec(AP);
  82   FreeVec(Pattern);
  83   //CurrentDir(oldlock);
  84
  85   //UnLock(dirlock);
  86
  87     return 0;
  88 }
  89
  90 #undef MatchFirst
  91 #undef MatchNext
  92 #undef MatchEnd
  93
  94
  95 LONG MyMatchFirst(STRPTR pat, struct AnchorPath * AP)
  96 {
  97   struct AChain * AC;
  98   struct AChain * AC_Prev = NULL;
  99   LONG PatLength;
 100   STRPTR ParsedPattern;
 101   BPTR firstlock;
 102
 103   if (!pat)
 104     return FALSE;
 105
 106   PatLength = 2*strlen(pat)+2;
 107
 108   ParsedPattern = AllocMem(PatLength, MEMF_ANY);
 109   if (NULL != ParsedPattern)
 110   {
 111     LONG PatStart = 0;
 112     LONG PatEnd   = 0;
 113     BOOL AllDone  = FALSE;
 114     LONG index;
 115     BOOL success = FALSE;
 116     /* put the preparsed string to some memory */
 117     /* If there are any wildcards then leave info */
 118     if (1 == ParsePatternNoCase(pat, ParsedPattern, PatLength))
 119       AP->ap_Flags = (BYTE)APF_ITSWILD;
 120
 121     /* First I search for the very first ':'. If a '/' comes along
 122        before that I quit. The string before and including the ':'
 123        is assumed to be an assigned director, for example 'libs:'.
 124        So I will start looking for the pattern in that directory.
 125      */
 126     while (TRUE)
 127     {
 128       if (ParsedPattern[PatEnd] == ':')
 129       {
 130         success = TRUE;
 131         break;
 132       }
 133       else
 134       {
 135         if ( ParsedPattern[PatEnd]         == '/'  ||
 136              ParsedPattern[PatEnd]         == '\0' ||
 137             (ParsedPattern[PatEnd] & 0x80) != 0
 138                            /* a token or nonprintable letter */)
 139         {
 140           PatEnd = 0;
 141           break;
 142         }
 143       }
 144       PatEnd++;
 145     }
 146
 147     /* Only if success == TRUE an assigned dir was found. */
 148     if (TRUE == success)
 149     {
 150       /* try to create a lock to that assigned dir. */
 151       char Remember = ParsedPattern[PatEnd+1];
 152       PatEnd++;
 153       ParsedPattern[PatEnd] = '\0';
 154
 155       firstlock = Lock(ParsedPattern, ACCESS_READ);
 156       /* check whether an error occurred */
 157       if (BNULL == firstlock)
 158       {
 159         FreeMem(ParsedPattern, PatLength);
 160         return ERROR_DIR_NOT_FOUND; /* hope that's the right one... */
 161       }
 162
 163       /* I have the correct lock. */
 164       ParsedPattern[PatEnd] = Remember;
 165       PatStart=PatEnd;
 166     }
 167     else
 168     {
 169       /* Create a lock to the current dir. */
 170       firstlock = CurrentDir(BNULL);
 171       firstlock = DupLock(firstlock);
 172       (void)CurrentDir(firstlock);
 173     }
 174
 175     /* Build the Anchor Chain. For every subdirector I allocate
 176        a AChain structure and link them all together */
 177     while (FALSE == AllDone)
 178     {
 179
 180
 181       /*
 182          Search for the next '/' in the pattern and everything behind
 183          the previous '/' and before this '/' will go to an_String
 184        */
 185       while (TRUE)
 186       {
 187         if (ParsedPattern[PatEnd] == '\0')
 188         {
 189           AllDone = TRUE;
 190           PatEnd--;
 191           break;
 192         }
 193         if (ParsedPattern[PatEnd] == '/')
 194         {
 195           PatEnd--;
 196           break;
 197         }
 198         PatEnd++;
 199       }
 200
 201       AC = AllocMem(sizeof(struct AChain)+(PatEnd-PatStart+2), MEMF_CLEAR);
 202       if (NULL == AC)
 203       {
 204         /* not so bad if this was not the very first AC. */
 205         if (NULL == AP->ap_Base)
 206         {
 207           /* oops, it was the very first one. I really cannot do anything for
 208              you. - sorry */
 209           FreeMem(ParsedPattern, PatLength);
 210           return ERROR_NO_FREE_STORE;
 211         }
 212
 213         /* let me out of here. I will at least try to do something for you.
 214            I can check the first few subdirs but that's gonna be it.
 215          */
 216         AP->ap_Flags |= APF_NOMEMERR;
 217         break;
 218       }
 219
 220       if (NULL == AP->ap_Base)
 221       {
 222         AP->ap_Base = AC;
 223         AP->ap_Current = AC;
 224       }
 225
 226       if (NULL != AC_Prev)
 227       {
 228         AC_Prev->an_Child = AC;
 229       }
 230       AC->an_Parent = AC_Prev;
 231       AC_Prev       = AC;
 232
 233       /* copy the part of the pattern to the end of the AChain. */
 234       index = 0;
 235       while (PatStart <= PatEnd)
 236       {
 237         AC->an_String[index] = ParsedPattern[PatStart];
 238         index++;
 239         PatStart++;
 240       }
 241       /* Put PatStart and PetEnd behind the '/' that was found. */
 242       PatStart   = PatEnd + 2;
 243       PatEnd    += 2;
 244       /*
 245          the trailing '\0' is there automatically as I allocated enough store
 246          with MEMF_CLEAR
 247       */
 248
 249     } /* while () */
 250
 251     /* The AnchorChain to work with is the very first one. */
 252     AC = AP->ap_Base;
 253     AC->an_Lock = firstlock;
 254
 255     /* look for the first file that matches the given pattern */
 256     success = Examine(AC->an_Lock, &AC->an_Info);
 257     success = ExNext (AC->an_Lock, &AC->an_Info);
 258     while (DOSTRUE == success &&
 259            DOSFALSE == MatchPatternNoCase(AC->an_String,
 260                                           AC->an_Info.fib_FileName))
 261     {
 262       /* I still haven't found what I've been looking for ... */
 263       success = ExNext(AC->an_Lock, &AC->an_Info);
 264     }
 265
 266     if (DOSFALSE == success)
 267     {
 268       return ERROR_NO_MORE_ENTRIES;
 269     }
 270
 271     /* Hooray! A matching file was found. Also show the data in AP */
 272     CopyMem(&AC->an_Info, &AP->ap_Info, sizeof(struct FileInfoBlock));
 273     if (0 != AP->ap_Strlen)
 274     {
 275        if (FALSE == writeFullPath(AP))
 276           return ERROR_BUFFER_OVERFLOW;
 277     }
 278     return 0;
 279
 280   }
 281   else
 282   {
 283     return ERROR_NO_FREE_STORE;
 284   }
 285
 286   return 0;
 287 }
 288
 289
 290 LONG MyMatchNext(struct AnchorPath * AP)
 291 {
 292   /* If the user says I am supposed to enter the directory then I first check
 293      whether it is a directory... */
 294   struct AChain * AC = AP->ap_Current;
 295   BOOL success;
 296   if (0 != (AP->ap_Flags & APF_DODIR ))
 297   {
 298     if (AC->an_Info.fib_DirEntryType >= 0 /* &&
 299         AC->an_Info.fib_DirEntryType != ST_SOFTLINK */)
 300     {
 301       /* Ok, it seems to be a directory so I will enter it. */
 302       /* See whether there's a AnchorChain for that dir... */
 303       if (NULL != AC->an_Child)
 304       {
 305         /* Ok, we're all set. */
 306         /* Lock the director by it's name. */
 307         AP->ap_Current = AC->an_Child;
 308         AC->an_Child->an_Lock = Lock(AC->an_Info.fib_FileName, ACCESS_READ);
 309         AC = AC->an_Child;
 310         Examine(AC->an_Lock, &AC->an_Info);
 311       }
 312     }
 313   }
 314   AP->ap_Flags &= ~(BYTE)(APF_DODIR|APF_DIDDIR);
 315
 316   /* AC points to the current AnchorChain */
 317   while (TRUE)
 318   {
 319     success = ExNext (AC->an_Lock, &AC->an_Info);
 320     while (DOSTRUE == success &&
 321            DOSFALSE == MatchPatternNoCase(AC->an_String,
 322                                           AC->an_Info.fib_FileName))
 323     {
 324       success = ExNext(AC->an_Lock, &AC->an_Info);
 325     }
 326
 327     if (DOSFALSE == success)
 328     {
 329       /* No more entries in this dir that match. So I might have to
 330          step back one directory. Unlock the current dir first,
 331          !!!!!???? but only if it is not the one from where I started
 332          Otherwise AROS crashes...
 333       */
 334
 335       if (NULL != AC->an_Parent)
 336         UnLock(AC->an_Lock);
 337
 338
 339       AC->an_Lock = BNULL;
 340       /* Are there any previous directories??? */
 341       if (NULL != AC->an_Parent)
 342       {
 343         /* Step back to this directory and go on searching here */
 344         AC = AC->an_Parent;
 345         AP->ap_Current = AC;
 346         CurrentDir(AC->an_Lock);
 347         /* I show this dir again as I come back from searching it */
 348         CopyMem(&AC->an_Info, &AP->ap_Info, sizeof(struct FileInfoBlock));
 349         AP->ap_Flags |= APF_DIDDIR;
 350         if (0 != AP->ap_Strlen)
 351         {
 352           if (FALSE == writeFullPath(AP))
 353             return ERROR_BUFFER_OVERFLOW;
 354         }
 355         return 0;
 356       }
 357       else
 358       {
 359         /* No previous directory, so I am done here... */
 360         return ERROR_NO_MORE_ENTRIES;
 361       }
 362     }
 363     else
 364     {
 365       /* Alright, I found a match... */
 366       CopyMem(&AC->an_Info, &AP->ap_Info, sizeof(struct FileInfoBlock));
 367       if (0 != AP->ap_Strlen)
 368       {
 369         if (FALSE == writeFullPath(AP))
 370           return ERROR_BUFFER_OVERFLOW;
 371       }
 372       return 0;
 373     }
 374   } /* while (TRUE) */
 375   return 0;
 376 }
 377
 378 void MyMatchEnd(struct AnchorPath * AP)
 379 {
 380   /* Free the AChain and unlock all locks that are still there */
 381   struct AChain * AC = AP->ap_Current;
 382   struct AChain * AC_tmp;
 383   /* Unlock everything */
 384   if (NULL == AC)
 385
 386   while (AC != AP->ap_Base)
 387   {
 388     UnLock(AC->an_Lock);
 389     AC = AC->an_Parent;
 390   }
 391   /* AC points to the very first AChain obj. in the list */
 392
 393   /* Free the AChain List */
 394   while (NULL != AC)
 395   {
 396     AC_tmp = AC->an_Child;
 397     FreeVec(AC);
 398     AC = AC_tmp;
 399   }
 400   /* Cleanup AP */
 401   AP->ap_Base = NULL;
 402   AP->ap_Current = NULL;
 403 }
 404
 405 BOOL writeFullPath(struct AnchorPath * AP)
 406 {
 407   struct AChain * AC = AP->ap_Base;
 408   BOOL end = FALSE;
 409   char * LastPos = (char *)&AP->ap_Buf;
 410   int copied = 0;
 411
 412   while (FALSE == end)
 413   {
 414     int len = strlen(AC->an_Info.fib_FileName);
 415     if (copied+len > AP->ap_Strlen)
 416     {
 417       return FALSE;
 418     }
 419     strcpy(&LastPos[copied], AC->an_Info.fib_FileName);
 420     copied += len;
 421
 422     if (AC != AP->ap_Current)
 423     {
 424       /* also add a '/' */
 425       if (copied+1 > AP->ap_Strlen)
 426       {
 427         return FALSE;
 428       }
 429       LastPos[copied]='/';
 430       copied++;
 431     }
 432     else
 433     {
 434       if (copied+1 > AP->ap_Strlen)
 435       {
 436         return FALSE;
 437       }
 438       LastPos[copied]='\0';
 439       end = TRUE;
 440     }
 441
 442     AC = AC->an_Child;
 443   }
 444   return TRUE;
 445 }