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