home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / SH162_2S.ZIP / PNMATCH.C < prev    next >
C/C++ Source or Header  |  1990-02-17  |  3KB  |  133 lines
  1. #include <stdlib.h>
  2.  
  3. /* File name pattern matching function */
  4.  
  5. int    pnmatch (string, pattern, flag)
  6. char    *string;            /* String to match                  */
  7. char    *pattern;            /* Pattern to match against         */
  8. int    flag;                /* Match using '$' & '^'            */
  9. {
  10.     register int    cur_s;        /* Current string character         */
  11.     register int    cur_p;        /* Current pattern character        */
  12.  
  13. /* Match $ and ^ ? */
  14.  
  15.     if (flag == 1)
  16.     {
  17.     while (*string)
  18.     {
  19.         if (pnmatch (string++, pattern, ++flag))
  20.         return 1;
  21.     }
  22.  
  23.     return 0;
  24.     }
  25.  
  26. /* Match string */
  27.  
  28.     while (cur_p = *(pattern++))
  29.     {
  30.     cur_s = *(string++);        /* Load current string character    */
  31.  
  32.         switch (cur_p)            /* Switch on pattern character      */
  33.         {
  34.             case '^':            /* Match start of string            */
  35.             {
  36.                 if (flag == 2)
  37.                     string--;
  38.  
  39.                 else if ((flag) || (cur_p != cur_s))
  40.             return 0;
  41.  
  42.                 break;
  43.             }
  44.  
  45.             case '$':            /* Match end of string              */
  46.             {
  47.                 if (!flag)
  48.                 {
  49.                     if (cur_p != cur_s)
  50.             return 0;
  51.  
  52.                     break;
  53.                 }
  54.  
  55.                 else
  56.             return ((cur_s) ? 0 : 1);
  57.             }
  58.  
  59.             case '[':            /* Match class of characters        */
  60.             {
  61.                 while(1)
  62.                 {
  63.                     if (!(cur_p = *(pattern++)))
  64.             return 0;
  65.  
  66.                     if (cur_p == ']')
  67.             return 0;
  68.  
  69.                     if (cur_s != cur_p)
  70.                     {
  71.                         if (*pattern == '-')
  72.                         {
  73.                             if(cur_p > cur_s)
  74.                                 continue;
  75.  
  76.                             if (cur_s > *(++pattern))
  77.                                 continue;
  78.                         }
  79.                         else
  80.                             continue;
  81.                     }
  82.  
  83.                     break;
  84.                 }
  85.  
  86.                 while (*pattern)
  87.                 {
  88.                     if (*(pattern++) == ']')
  89.                         break;
  90.                 }
  91.             }
  92.  
  93.             case '?':            /* Match any character              */
  94.             {
  95.                 if (!cur_s)
  96.             return 0;
  97.  
  98.                 break;
  99.             }
  100.  
  101.             case '*':            /* Match any number of any character*/
  102.             {
  103.                 string--;
  104.  
  105.                 do
  106.                 {
  107.                     if (pnmatch (string, pattern, 0))
  108.             return 1;
  109.                 }
  110.                 while (*(string++));
  111.  
  112.         return 0;
  113.             }
  114.  
  115.             case '\\':            /* Next character is non-meta       */
  116.             {
  117.                 if (!(cur_p = *(pattern++)))
  118.             return 0;
  119.             }
  120.  
  121.             default:            /* Match against current pattern    */
  122.             {
  123.                 if (cur_p != cur_s)
  124.             return 0;
  125.  
  126.                 break;
  127.             }
  128.         }
  129.     }
  130.  
  131.     return ((flag || (!(*string))) ? 1 : 0);
  132. }
  133.