rom/dos/match_misc.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Support functions for MatchFirst/MatchNext/MatchEnd
   6     Lang: english
   7 */
   8
   9 /****************************************************************************************/
  10
  11 #include <exec/memory.h>
  12 #include <dos/dos.h>
  13 #include <dos/dosextens.h>
  14 #include <dos/dosasl.h>
  15 #include <proto/dos.h>
  16 #include <proto/exec.h>
  17
  18 #include "dos_intern.h"
  19 #include <aros/debug.h>
  20
  21 #include <string.h>
  22
  23 /****************************************************************************************/
  24
  25 #define COMPTYPE_NORMAL  1
  26 #define COMPTYPE_PATTERN 2
  27 #define COMPTYPE_UNKNOWN 3
  28
  29 /****************************************************************************************/
  30
  31 struct AChain *Match_AllocAChain(LONG extrasize, struct DosLibrary *DOSBase)
  32 {
  33     return AllocVec(sizeof(struct AChain) + extrasize, MEMF_PUBLIC | MEMF_CLEAR);
  34 }
  35
  36 /****************************************************************************************/
  37
  38 void Match_FreeAChain(struct AChain *ac, struct DosLibrary *DOSBase)
  39 {
  40     FreeVec(ac);
  41 }
  42
  43 /****************************************************************************************/
  44
  45 static void RemoveTrailingSlash(STRPTR s)
  46 {
  47     LONG len = strlen(s);
  48
  49     if (len >= 2)
  50     {
  51         if ((s[len - 1] == '/') &&
  52             ((s[len - 2] != '/') && (s[len - 2] != ':')))
  53         {
  54             s[len - 1] = '\0';
  55         }
  56     }
  57 }
  58
  59 /**************************************************************************
  60
  61 The job of Match_BuildAChainList is to split the pattern string passed to
  62 MatchFirst into path components. Most imporant rules (as found out after
  63 hours of testing on Amiga):
  64
  65   - Each path component containing a pattern string is put into a single
  66     AChain
  67   - If there are several successive path components *without* pattern then
  68     this are merged into one single AChain.
  69   - No matter what: the last path component always gets into its own single
  70     AChain.
  71
  72 Examples: [<???>] is one AChain
  73
  74   pictures                          [pictures]
  75   pictures/#?                       [pictures} [#?]
  76   work:                             [work:] []
  77   work:pictures                     [work:} [pictures]
  78   work:pictures/#?                  [work:pictures] [#?]
  79   work:pictures/aros                [work:pictures] [aros]
  80   work:pictures/aros/games          [work:pictures/aros] [games]
  81   work:#?/aros/games                [work:] [#?] [aros] [games}
  82   work:#?/#?/aros/games/quake       [work:} [#?] [#?] [aros/games] [quake]
  83
  84 **************************************************************************/
  85
  86 LONG Match_BuildAChainList(STRPTR pattern, struct AnchorPath *ap,
  87                            struct AChain **retac, struct DosLibrary *DOSBase)
  88 {
  89     struct AChain       *baseac = 0, *prevac = 0, *ac;
  90     STRPTR              patterncopy = 0;
  91     STRPTR              patternstart, patternend, patternpos;
  92     LONG                len, error = 0;
  93     WORD                comptype = COMPTYPE_UNKNOWN;
  94     WORD                compcount = 0;
  95     WORD                i;
  96     UBYTE               c;
  97
  98     *retac = 0;
  99
 100     len = strlen(pattern);
 101
 102     patterncopy = AllocVec(len + 1, MEMF_PUBLIC);
 103     if (!patterncopy)
 104     {
 105         error = ERROR_NO_FREE_STORE;
 106         goto done;
 107     }
 108
 109     strcpy(patterncopy, pattern);
 110
 111     RemoveTrailingSlash(patterncopy);
 112
 113     patternstart = patterncopy;
 114
 115     patternpos = strchr(patterncopy, ':');
 116     if (!patternpos)
 117     {
 118         comptype = COMPTYPE_UNKNOWN;
 119         patternpos = patternstart;
 120         patternend = patternstart;
 121     }
 122     else
 123     {
 124         comptype = COMPTYPE_NORMAL;
 125         patternend = patternpos++;
 126         compcount = 1;
 127     }
 128
 129     do
 130     {
 131         for(;;)
 132         {
 133             c = *patternpos;
 134             if (c == '/')
 135             {
 136                 if (comptype == COMPTYPE_UNKNOWN)
 137                 {
 138                     comptype = COMPTYPE_NORMAL;
 139                     patternend = patternpos;
 140                 }
 141                 else if (comptype == COMPTYPE_NORMAL)
 142                 {
 143                     patternend = patternpos;
 144                     compcount++;
 145                 }
 146                 if (comptype == COMPTYPE_PATTERN)
 147                 {
 148                     patternend = patternpos;
 149                     break;
 150                 }
 151             }
 152             else if (c == '\0')
 153             {
 154                 if (comptype == COMPTYPE_UNKNOWN)
 155                 {
 156                     comptype = COMPTYPE_NORMAL;
 157                     patternend = patternpos;
 158                     break;
 159                 }
 160                 if (comptype == COMPTYPE_NORMAL)
 161                 {
 162                     compcount++;
 163                     break;
 164                 }
 165                 patternend = patternpos;
 166                 break;
 167             }
 168             else if ((c == '#') ||
 169                      (c == '~') ||
 170                      (c == '[') ||
 171                      (c == ']') ||
 172                      (c == '?') ||
 173                      (c == '*') ||
 174                      (c == '(') ||
 175                      (c == ')') ||
 176                      (c == '|') ||
 177                      (c == '%'))
 178             {
 179                 if (comptype == COMPTYPE_NORMAL)
 180                 {
 181                     break;
 182                 }
 183                 comptype = COMPTYPE_PATTERN;
 184             }
 185
 186             patternpos++;
 187
 188         } /* for(;;) */
 189
 190         len = (LONG)(patternend - patternstart + 2);
 191         if (comptype == COMPTYPE_PATTERN) len = len * 2 + 2;
 192
 193         ac = Match_AllocAChain(len, DOSBase);
 194         if (!ac)
 195         {
 196             error = ERROR_NO_FREE_STORE;
 197             goto done;
 198         }
 199
 200         if (comptype == COMPTYPE_NORMAL)
 201         {
 202             if (*patternend == '\0')
 203             {
 204                 strcpy(ac->an_String, patternstart);
 205             } else {
 206                 c = patternend[1];
 207                 patternend[1] = '\0';
 208                 strcpy(ac->an_String, patternstart);
 209                 patternend[1] = c;
 210             }
 211
 212         } /* if (comptype == COMPTYPE_NORMAL) */
 213         else
 214         {
 215             if (*patternend == '\0')
 216             {
 217                 i = ParsePatternNoCase(patternstart, ac->an_String, len);
 218                 if (i == 0)
 219                 {
 220                     /* It is not a pattern, although we guessed it was one.
 221                        Do the strcpy, otherwise we have uppercase stuff in
 222                        ac->an_String because of ParsePatternNOCASE() */
 223                     strcpy(ac->an_String, patternstart);
 224                 }
 225             }
 226             else
 227             {
 228                 c = patternend[1];
 229                 patternend[1] = '\0';
 230                 i = ParsePatternNoCase(patternstart, ac->an_String, len);
 231                 if (i == 0)
 232                 {
 233                     /* It is not a pattern, although we guessed it was one.
 234                        Do the strcpy, otherwise we have uppercase stuff in
 235                        ac->an_String because of ParsePatternNOCASE() */
 236                     strcpy(ac->an_String, patternstart);
 237                 }
 238                 patternend[1] = c;
 239             }
 240
 241             if (i == -1)
 242             {
 243                 error = ERROR_BAD_TEMPLATE;
 244                 Match_FreeAChain(ac, DOSBase);ac = 0;
 245                 goto done;
 246             }
 247
 248             if (i)
 249             {
 250                 ac->an_Flags |= DDF_PatternBit;
 251                 ap->ap_Flags |= APF_ITSWILD;
 252             }
 253
 254         } /* if (comptype == COMPTYPE_NORMAL) else ... */
 255
 256         RemoveTrailingSlash(ac->an_String);
 257
 258         if (!prevac)
 259         {
 260             baseac = ac;
 261         }
 262         else
 263         {
 264             prevac->an_Child = ac;
 265             ac->an_Parent = prevac;
 266         }
 267
 268         prevac = ac;
 269
 270         patternpos = patternend;
 271         comptype = COMPTYPE_UNKNOWN;
 272         patternstart = patternend = patternpos + 1;
 273         compcount = 0;
 274
 275     } while (*patternpos++ != '\0');
 276
 277 done:
 278     if (patterncopy) FreeVec(patterncopy);
 279
 280     if (!error)
 281     {
 282 #if MATCHFUNCS_NO_DUPLOCK
 283         /*
 284         * No DupLock() here, because then we would have to UnLock it in
 285         * MatchEnd and we would not know any valid lock to which we could
 286         * CurrentDir after, because we must make sure there is a valid
 287         * CurrentDir after MatchEnd.
 288         */
 289
 290         baseac->an_Lock = CurrentDir(0);
 291         CurrentDir(baseac->an_Lock);
 292 #endif
 293
 294         *retac = baseac;
 295     }
 296     else
 297     {
 298         ap->ap_Flags |= APF_NOMEMERR;
 299
 300         if (baseac)
 301         {
 302             #define nextac prevac /* to not have to add another variable */
 303
 304             ac = baseac;
 305             while(ac)
 306             {
 307                 nextac = ac->an_Child;
 308                 Match_FreeAChain(ac, DOSBase);
 309                 ac = nextac;
 310             }
 311         }
 312     }
 313
 314     return error;}
 315
 316 /******************************************************************************/
 317
 318 LONG Match_MakeResult(struct AnchorPath *ap, struct DosLibrary *DOSBase)
 319 {
 320 #if 1
 321     LONG error = 0;
 322
 323     ap->ap_Info = ap->ap_Current->an_Info;
 324     if (ap->ap_Strlen)
 325     {
 326         struct AChain *ac;
 327
 328         ap->ap_Buf[0] = 0;
 329
 330         for(ac = ap->ap_Base; (ac && !error); ac = ac->an_Child)
 331         {
 332             if (!AddPart(ap->ap_Buf,
 333                          ((ac->an_Flags & DDF_PatternBit) ? ac->an_Info.fib_FileName : ac->an_String),
 334                          ap->ap_Strlen))
 335             {
 336                 error = IoErr();
 337             }
 338         }
 339
 340     }
 341 #else
 342     LONG error = 0;
 343
 344     ap->ap_Info = ap->ap_Current->an_Info;
 345     if (ap->ap_Strlen)
 346     {
 347         ap->ap_Buf[0] = 0;
 348         if (NameFromLock(ap->ap_Current->an_Lock, ap->ap_Buf, ap->ap_Strlen))
 349         {
 350             if (!AddPart(ap->ap_Buf, ap->ap_Current->an_Info.fib_FileName, ap->ap_Strlen))
 351             {
 352                 error = IoErr();
 353             }
 354         } else {
 355             error = IoErr();
 356         }
 357     }
 358 #endif
 359
 360     return error;
 361 }
 362
 363 /******************************************************************************/