home *** CD-ROM | disk | FTP | other *** search
/ Aminet 18 / aminetcdnumber181997.iso / Aminet / misc / emu / AROSdev.lha / AROS / rom / dos / matchpatternnocase.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-27  |  8.4 KB  |  312 lines
  1. /*
  2.     (C) 1995-96 AROS - The Amiga Replacement OS
  3.     $Id: matchpatternnocase.c,v 1.4 1997/01/27 00:36:26 ldp Exp $
  4.     $Log: matchpatternnocase.c,v $
  5.     Revision 1.4  1997/01/27 00:36:26  ldp
  6.     Polish
  7.  
  8.     Revision 1.3  1996/12/09 13:53:34  aros
  9.     Added empty templates for all missing functions
  10.  
  11.     Moved #include's into first column
  12.  
  13.     Revision 1.2  1996/10/24 15:50:33  aros
  14.     Use the official AROS macros over the __AROS versions.
  15.  
  16.     Revision 1.1  1996/09/11 12:54:46  digulla
  17.     A couple of new DOS functions from M. Fleischer
  18.  
  19.     Desc:
  20.     Lang: english
  21. */
  22. #include <exec/memory.h>
  23. #include <proto/exec.h>
  24. #include <proto/utility.h>
  25. #include <dos/dosextens.h>
  26. #include "dos_intern.h"
  27.  
  28. /*****************************************************************************
  29.  
  30.     NAME */
  31. #include <proto/dos.h>
  32.  
  33.     AROS_LH2(BOOL, MatchPatternNoCase,
  34.  
  35. /*  SYNOPSIS */
  36.     AROS_LHA(STRPTR, pat, D1),
  37.     AROS_LHA(STRPTR, str, D2),
  38.  
  39. /*  LOCATION */
  40.     struct DosLibrary *, DOSBase, 162, Dos)
  41.  
  42. /*  FUNCTION
  43.     Similar to MatchPattern(), only case insensitive (see there for
  44.     more information). For use with ParsePatternNoCase().
  45.  
  46.     INPUTS
  47.  
  48.     RESULT
  49.  
  50.     NOTES
  51.  
  52.     EXAMPLE
  53.  
  54.     BUGS
  55.  
  56.     SEE ALSO
  57.     MatchPattern(), ParsePatternNoCase().
  58.  
  59.     INTERNALS
  60.  
  61.     HISTORY
  62.     29-10-95    digulla automatically created from
  63.                 dos_lib.fd and clib/dos_protos.h
  64.  
  65. *****************************************************************************/
  66. {
  67.     AROS_LIBFUNC_INIT
  68.     AROS_LIBBASE_EXT_DECL(struct DosLibrary *,DOSBase)
  69.  
  70.     STRPTR s;
  71.     LONG match=0;
  72.     struct markerarray ma, *macur=&ma, *cur2;
  73.     LONG macnt=0, cnt2;
  74.     ULONG level;
  75.     UBYTE a, b, c, t;
  76.     LONG error;
  77. #define ERROR(a) { error=(a); goto end; }
  78.  
  79.     ma.next=ma.prev=NULL;
  80.     for(;;)
  81.         switch(*pat)
  82.         {
  83.             case MP_MULT: /* _#(_a) */
  84.                 PUSH(0,++pat,str);
  85.                 level=1;
  86.                 for(;;)
  87.                 {
  88.                     c=*pat++;
  89.                     if(c==MP_MULT)
  90.                         level++;
  91.                     else if(c==MP_MULT_END)
  92.                         if(!--level)
  93.                             break;
  94.                 }
  95.                 break;
  96.             case MP_MULT_END: /* #(a_)_ */
  97.                 level=1;
  98.                 for(;;)
  99.                 {
  100.                     c=*--pat;
  101.                     if(c==MP_MULT_END)
  102.                         level++;
  103.                     else if(c==MP_MULT)
  104.                         if(!--level)
  105.                             break;
  106.                 }
  107.                 break;
  108.             case MP_NOT: /* _~(_a) */
  109.                 s=++pat;
  110.                 level=1;
  111.                 for(;;)
  112.                 {
  113.                     c=*s++;
  114.                     if(c==MP_NOT)
  115.                         level++;
  116.                     else if(c==MP_NOT_END)
  117.                         if(!--level)
  118.                             break;
  119.                 }
  120.                 PUSH(1,s,str);
  121.                 break;
  122.             case MP_NOT_END: /* ~(a_)_ */
  123.                 cnt2=macnt;
  124.                 cur2=macur;
  125.                 do
  126.                 {
  127.                     cnt2--;
  128.                     if(cnt2<0)
  129.                     {
  130.                         cnt2=127;
  131.                         cur2=cur2->prev;
  132.                     }
  133.                 }while(!cur2->marker[cnt2].type);
  134.                 if(!*str++)
  135.                 {
  136.                     macnt=cnt2;
  137.                     macur=cur2;
  138.                 }else
  139.                     if(str>cur2->marker[cnt2].str)
  140.                         cur2->marker[cnt2].str=str;
  141.                 POP(t,pat,str);
  142.                 if(t&&*str)
  143.                 { PUSH(1,pat,str+1); }
  144.                 break;
  145.             case MP_OR: /* ( */
  146.                 s=++pat;
  147.                 level=1;
  148.                 for(;;)
  149.                 {
  150.                     c=*s++;
  151.                     if(c==MP_OR)
  152.                         level++;
  153.                     else if(c==MP_OR_NEXT)
  154.                     {
  155.                         if(level==1)
  156.                         { PUSH(0,s,str); }
  157.                     }else if(c==MP_OR_END)
  158.                         if(!--level)
  159.                             break;
  160.                 }
  161.                 break;
  162.             case MP_OR_NEXT: /* | */
  163.                 pat++;
  164.                 level=1;
  165.                 for(;;)
  166.                 {
  167.                     c=*pat++;
  168.                     if(c==MP_OR)
  169.                         level++;
  170.                     else if(c==MP_OR_END)
  171.                         if(!--level)
  172.                             break;
  173.                 }
  174.                 break;
  175.             case MP_OR_END: /* ) */
  176.                 pat++;
  177.                 break;
  178.             case MP_SINGLE: /* ? */
  179.                 pat++;
  180.                 if(*str)
  181.                     str++;
  182.                 else
  183.                 {
  184.                     POP(t,pat,str);
  185.                     if(t&&*str)
  186.                     { PUSH(1,pat,str+1); }
  187.                 }
  188.                 break;
  189.             case MP_SET: /* [ */
  190.                 pat++;
  191.                 for(;;)
  192.                 {
  193.                     a=b=*pat++;
  194.                     if(a==MP_SET_END)
  195.                     {
  196.                         POP(t,pat,str);
  197.                         if(t&&*str)
  198.                         { PUSH(1,pat,str+1); }
  199.                         break;
  200.                     }
  201.                     if(a==MP_ESCAPE)
  202.                         a=b=*pat++ +0x80;
  203.                     else if(a==MP_DASH)
  204.                     {
  205.                         a=*pat++;
  206.                         if(a==MP_ESCAPE)
  207.                             a=*pat++ +0x80;
  208.                         b=*pat++;
  209.                         if(b==MP_ESCAPE)
  210.                             b=*pat++ +0x80;
  211.                     }
  212.                     c=ToLower(*str);
  213.                     if(c>=a&&c<=b)
  214.                     {
  215.                         str++;
  216.                         while(*pat++!=MP_SET_END)
  217.                             ;
  218.                         break;
  219.                     }
  220.                 }
  221.                 break;
  222.             case MP_NOT_SET: /* [~ */
  223.                 if(!*str)
  224.                 {
  225.                     POP(t,pat,str);
  226.                     if(t&&*str)
  227.                     { PUSH(1,pat,str+1); }
  228.                     break;
  229.                 }
  230.                 pat++;
  231.                 for(;;)
  232.                 {
  233.                     a=b=*pat++;
  234.                     if(a==MP_SET_END)
  235.                     {
  236.                         str++;
  237.                         break;
  238.                     }
  239.                     if(a==MP_ESCAPE)
  240.                         a=b=*pat++ +0x80;
  241.                     else if(a==MP_DASH)
  242.                     {
  243.                         a=*pat++;
  244.                         if(a==MP_ESCAPE)
  245.                             a=*pat++ +0x80;
  246.                         b=*pat++;
  247.                         if(b==MP_ESCAPE)
  248.                             b=*pat++ +0x80;
  249.                     }
  250.                     c=ToLower(*str);
  251.                     if(c>=a&&c<=b)
  252.                     {
  253.                         POP(t,pat,str);
  254.                         if(t&&*str)
  255.                         { PUSH(1,pat,str+1); }
  256.                         break;
  257.                     }
  258.                 }
  259.                 break;
  260.             case MP_ALL: /* #? */
  261.                 /* This often used pattern has extra treatment to be faster */
  262.                 if(*str)
  263.                 { PUSH(0,pat,str+1); }
  264.                 pat++;
  265.                 break;
  266.             case 0:
  267.                 if(!*str)
  268.                 {
  269.                     match=1;
  270.                     ERROR(0);
  271.                 }else
  272.                 {
  273.                     POP(t,pat,str);
  274.                     if(t&&*str)
  275.                     { PUSH(1,pat,str+1); }
  276.                 }
  277.                 break;
  278.             case MP_ESCAPE:
  279.                 pat++;
  280.                 if(0x80+*pat++==*str)
  281.                     str++;
  282.                 else
  283.                 {
  284.                     POP(t,pat,str);
  285.                     if(t&&*str)
  286.                     { PUSH(1,pat,str+1); }
  287.                 }
  288.                 break;
  289.             default:
  290.                 if(*pat++==ToLower(*str))
  291.                     str++;
  292.                 else
  293.                 {
  294.                     POP(t,pat,str);
  295.                     if(t&&*str)
  296.                     { PUSH(1,pat,str+1); }
  297.                 }
  298.                 break;
  299.         }
  300. end:
  301.     macur=ma.next;
  302.     while(macur!=NULL)
  303.     {
  304.         struct markerarray *next=macur->next;
  305.         FreeMem(macur,sizeof(struct markerarray));
  306.         macur=next;
  307.     }
  308.     ((struct Process *)FindTask(NULL))->pr_Result2=error;
  309.     return match;
  310.     AROS_LIBFUNC_EXIT
  311. } /* MatchPatternNoCase */
  312.