home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: Java / Java.zip / jload18.zip / regexp.java < prev    next >
Encoding:
Java Source  |  1998-12-31  |  3.7 KB  |  163 lines
  1. /*
  2.  *  Smart Cache , http proxy caching server
  3.  *  Copyright (C) 1998 Radim Kolar <hsn@cybermail.net>
  4.  *
  5.  *  This program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2, or (at your option)
  8.  *  any later version.
  9.  *
  10.  *  This program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  *  GNU General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with this program; if not, write to the Free Software
  17.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  *
  19.  */
  20.  
  21. public final class regexp
  22. {
  23.  public boolean ignoreCase; 
  24.  
  25.  private String elements[];
  26.  
  27.  private String prefix;
  28.  private String suffix;
  29.  
  30.  private int prefixlen;
  31.  private int suffixlen;
  32.  
  33.  private boolean exact;
  34.  
  35.  
  36.  regexp(String exp, boolean ign)
  37.  {
  38.   ignoreCase=ign;
  39.   exact=false;
  40.   int i;
  41.   
  42.   if(exp.indexOf('*',0)==-1) { exact=true; 
  43.                                prefix=exp; 
  44.                                prefixlen=exp.length(); 
  45.                                if(ign) prefix=prefix.toLowerCase();
  46.                                return;
  47.                              }
  48.   i=1;
  49.   if(!exp.startsWith("*"))
  50.    {
  51.     /* mame prefix */
  52.     prefix=exp.substring(0,exp.indexOf('*',0));
  53.     if(ign) prefix=prefix.toLowerCase();
  54.     prefixlen=prefix.length();
  55.     i=prefixlen+1;
  56.    }
  57.    int pos;
  58.    String part;
  59.    while(true)
  60.    {
  61.     pos=exp.indexOf('*',i);
  62.     if(pos==-1)
  63.       {
  64.        /* mame suffix */
  65.        if(i==exp.length()) return;
  66.        suffix=exp.substring(i);
  67.        if(ign) suffix=suffix.toLowerCase();
  68.        suffixlen=suffix.length();
  69.        return;
  70.       }
  71.       
  72.     part=exp.substring(i,pos);
  73.     if(ign) part=part.toLowerCase();
  74.     if(!part.equals(""))
  75.      {
  76.       /* pridame part do pole */
  77.       
  78.        if(elements==null) elements=new String[1];
  79.         else
  80.        {
  81.         String tmp[]=new String[elements.length+1];
  82.         System.arraycopy(elements,0,tmp,0,elements.length);
  83.         elements=tmp;
  84.        } 
  85.       elements[elements.length-1]=part;
  86.      }/* pridani */
  87.      
  88.     i=pos+1;
  89.     if(i>=exp.length()) break;
  90.     
  91.    
  92.    }/* while */
  93.  
  94.  }
  95.  
  96.  /* DEBUG VERZE
  97.  public String toString()
  98.  {
  99.   String result="prefix="+prefix+"\nsuffix="+suffix+"\nelements=";
  100.   if (elements==null) return result+="null";
  101.   for(int i=0;i<elements.length;i++)
  102.    result+=elements[i]+",";
  103.  
  104.   return result;
  105.  }
  106.  */
  107.  
  108.  
  109.  final public String toString()
  110.  {
  111.   if(exact==true) return prefix;
  112.   String result;
  113.   if(prefix==null) result="*";
  114.    else
  115.     result=prefix;
  116.   /* pridat elementy */
  117.   if(elements!=null)
  118.    for(int i=0;i<elements.length;i++)
  119.      result+=elements[i]+"*";
  120.   
  121.   /* suffix */
  122.   if(suffix!=null) result+=suffix;
  123.    else
  124.     if(elements==null) result+="*";
  125.   
  126.   return result;
  127.  }
  128.  final public boolean matches(String str)
  129.  {
  130.   int pos;
  131.   pos=0;
  132.   if(ignoreCase) str=str.toLowerCase();
  133.   if(exact) return str.equals(prefix);
  134.   
  135.   if(prefix!=null)
  136.    if(!str.startsWith(prefix)) return false;
  137.        else
  138.      pos=prefixlen;
  139.   if(elements!=null)
  140.    {
  141.     int j=elements.length;
  142.     for(int i=0;i<j;i++)
  143.      {
  144.      if( (pos=str.indexOf(elements[i],pos))==-1 ) return false;
  145.      pos+=elements[i].length();
  146.      }
  147.    }
  148.   if(suffix==null) return true; 
  149.   if(str.length()-pos<suffixlen) return false;
  150.   
  151.   return str.endsWith(suffix);
  152.  }
  153.  
  154.  /*
  155.  public static void main(String argv[])
  156.  {
  157.   if (argv.length<2) return;
  158.   regexp r=new regexp(argv[0],false);
  159.   System.out.println(r);
  160.   System.out.println("Matches : "+argv[1]+" : "+r.matches(argv[1]));
  161.  }
  162.  */
  163. }