src/com/stevesoft/pat/FileRegex.java

   1 //
   2 // This software is now distributed according to
   3 // the Lesser Gnu Public License.  Please see
   4 // http://www.gnu.org/copyleft/lesser.txt for
   5 // the details.
   6 //    -- Happy Computing!
   7 //
   8 package com.stevesoft.pat;
   9
  10 import java.io.*;
  11 import java.util.*;
  12
  13 /**
  14  * This class is a different form of Regex designed to work more like the file
  15  * matching utility of a Unix shell. It is implemented by some simple string
  16  * transformations: <center> <table border=1>
  17  * <tr>
  18  * <td> FileRegex </td>
  19  * <td> Regex </td>
  20  * <tr>
  21  * <td> * </td>
  22  * <td> .* </td>
  23  * <tr>
  24  * <td> . </td>
  25  * <td> \. </td>
  26  * <tr>
  27  * <td> { </td>
  28  * <td> (?: </td>
  29  * <tr>
  30  * <td> {?! </td>
  31  * <td> (?! </td>
  32  * <tr>
  33  * <td> {?= </td>
  34  * <td> (?= </td>
  35  * <tr>
  36  * <td> {?? </td>
  37  * <td> (?? </td>
  38  * <tr>
  39  * <td> } </td>
  40  * <td> ) </td>
  41  * <tr>
  42  * <td> ? </td>
  43  * <td> . </td>
  44  * <tr>
  45  * <td> {,} </td>
  46  * <td> (|) </td>
  47  * </table> </center> Note that a FileRegex pattern always ends with the Regex
  48  * pattern element "$". If you like to experiment, try making FileRegex's and
  49  * then printing them out. The toString() method does a decompile of the pattern
  50  * to a standard Regex. Here are some more complete examples: <center> <table
  51  * border=3>
  52  * <tr>
  53  * <td> FileRegex </td>
  54  * <td> Regex </td>
  55  * <tr>
  56  * <td>*.java </td>
  57  * <td> .*\.java$ </td>
  58  * <tr>
  59  * <td>*.{java,html} </td>
  60  * <td> .*\.(java|html)$ </td>
  61  * <tr>
  62  * <td> foo.[chC] </td>
  63  * <td> foo.[chC]$ </td>
  64  * </table> </center>
  65  */
  66 public class FileRegex extends Regex
  67 {
  68 //  /** Build an unitialized FileRegex. */
  69 //  public FileRegex()
  70 //  {
  71 //    dirflag = EITHER;
  72 //  }
  73 //
  74 //  /** Build a FileRegex form String s. */
  75 //  public FileRegex(String s)
  76 //  {
  77 //    super(s);
  78 //    dirflag = EITHER;
  79 //  }
  80 //
  81 //  /**
  82 //   * Compile a new pattern. Throws
  83 //   *
  84 //   * @exception com.stevesoft.pat.RegSyntax
  85 //   *                    for nonsensical patterns like "[9-0]+" just as Regex
  86 //   *                    does.
  87 //   * @see com.stevesoft.pat#compile(java.lang.String)
  88 //   */
  89 //  public void compile(String s) throws RegSyntax
  90 //  {
  91 //    String npat = toFileRegex(s);
  92 //    super.compile(npat);
  93 //    if (File.separatorChar == '\\') // MS-DOS
  94 //    {
  95 //      ignoreCase = true;
  96 //    }
  97 //  }
  98 //
  99 //  /**
 100 //   * This is the method required by FileNameFilter. To get a listing of files in
 101 //   * the current directory ending in .java, do this:
 102 //   *
 103 //   * <pre>
 104 //   * File dot = new File(&quot;.&quot;);
 105 //   *
 106 //   * FileRegex java_files = new FileRegex(&quot;*.java&quot;);
 107 //   *
 108 //   * String[] file_list = dot.list(java_files);
 109 //   * </pre>
 110 //   */
 111 //  public boolean accept(File dir, String s)
 112 //  {
 113 //    if (dirflag != EITHER)
 114 //    {
 115 //      File f = new File(s);
 116 //      if (f.isDirectory() && dirflag == NONDIR)
 117 //      {
 118 //        return false;
 119 //      }
 120 //      if (!f.isDirectory() && dirflag == DIR)
 121 //      {
 122 //        return false;
 123 //      }
 124 //    }
 125 //    return matchAt(s, 0);
 126 //  }
 127 //
 128 //  int dirflag = 0;
 129 //
 130 //  final static int EITHER = 0, DIR = 1, NONDIR = 2;
 131 //
 132 //  /**
 133 //   * Provides an alternative to File.list -- this separates its argument
 134 //   * according to File.pathSeparator. To each path, it splits off a directory --
 135 //   * all characters up to and including the first instance of File.separator --
 136 //   * and a file pattern -- the part that comes after the directory. It then
 137 //   * produces a list of all the pattern matches on all the paths. Thus
 138 //   * "*.java:../*.java" would produce a list of all the java files in this
 139 //   * directory and in the ".." directory on a Unix machine. "*.java;..\\*.java"
 140 //   * would do the same thing on a Dos machine.
 141 //   */
 142 //  public static String[] list(String f)
 143 //  {
 144 //    return list(f, EITHER);
 145 //  }
 146 //
 147 //  static String[] list(String f, int df)
 148 //  {
 149 //    // return list_(f,new FileRegex());
 150 //    StringTokenizer st = new StringTokenizer(f, File.pathSeparator);
 151 //    Vector v = new Vector();
 152 //    while (st.hasMoreTokens())
 153 //    {
 154 //      String path = st.nextToken();
 155 //      list1(path, v, df, true);
 156 //    }
 157 //    String[] sa = new String[v.size()];
 158 //    v.copyInto(sa);
 159 //    return sa;
 160 //  }
 161 //
 162 //  final static Regex root = new Regex(File.separatorChar == '/' ? "/$"
 163 //          : "(?:.:|)\\\\$");
 164 //
 165 //  static void list1(String path, Vector v, int df, boolean rec)
 166 //  {
 167 //    // if path looks like a/b/c/ or d:\ then add .
 168 //    if (root.matchAt(path, 0))
 169 //    {
 170 //      v.addElement(path + ".");
 171 //      return;
 172 //    }
 173 //    File f = new File(path);
 174 //    if (f.getParent() != null && rec)
 175 //    {
 176 //      Vector v2 = new Vector();
 177 //      list1(f.getParent(), v2, DIR, true);
 178 //      for (int i = 0; i < v2.size(); i++)
 179 //      {
 180 //        String path2 = ((String) v2.elementAt(i)) + File.separator
 181 //                + f.getName();
 182 //        list1(path2, v, df, false);
 183 //      }
 184 //    }
 185 //    else
 186 //    {
 187 //      File base = new File(path);
 188 //
 189 //      String dir_s = base.getParent();
 190 //      if (dir_s == null)
 191 //      {
 192 //        dir_s = ".";
 193 //      }
 194 //      File dir = new File(dir_s);
 195 //
 196 //      FileRegex fr = new FileRegex(base.getName());
 197 //      if (fr.isLiteral())
 198 //      {
 199 //        v.addElement(dir_s + File.separator + base.getName());
 200 //        return;
 201 //      }
 202 //      fr.dirflag = df;
 203 //      String[] sa = dir.list(fr);
 204 //      if (sa == null)
 205 //      {
 206 //        return;
 207 //      }
 208 //      for (int i = 0; i < sa.length; i++)
 209 //      {
 210 //        v.addElement(dir_s + File.separator + sa[i]);
 211 //      }
 212 //    }
 213 //  }
 214 //
 215 //  /**
 216 //   * This method takes a file regular expression, and translates it into the
 217 //   * type of pattern used by a normal Regex.
 218 //   */
 219 //  public static String toFileRegex(String s)
 220 //  {
 221 //    StrPos sp = new StrPos(s, 0);
 222 //    StringBuffer sb = new StringBuffer();
 223 //    if (sp.incMatch("{?e="))
 224 //    {
 225 //      char e = sp.thisChar();
 226 //      sp.inc();
 227 //      if (sp.incMatch("}"))
 228 //      {
 229 //        sb.append("(?e=" + e + ")^");
 230 //      }
 231 //      else
 232 //      {
 233 //        sb.append("^(?e=");
 234 //      }
 235 //      sp.esc = e;
 236 //    }
 237 //    int ParenLvl = 0;
 238 //    while (!sp.eos())
 239 //    {
 240 //      if (File.separatorChar == '\\')
 241 //      {
 242 //        if (sp.escaped())
 243 //        {
 244 //          sb.append("\\\\");
 245 //        }
 246 //        sp.dontMatch = false;
 247 //      }
 248 //      if (sp.incMatch("?"))
 249 //      {
 250 //        sb.append(".");
 251 //      }
 252 //      else if (sp.incMatch("."))
 253 //      {
 254 //        sb.append(sp.esc);
 255 //        sb.append('.');
 256 //      }
 257 //      else if (sp.incMatch("{??"))
 258 //      {
 259 //        sb.append("(??");
 260 //        ParenLvl++;
 261 //        // allow negative lookahead to work
 262 //      }
 263 //      else if (sp.incMatch("{?!"))
 264 //      {
 265 //        sb.append("(?!");
 266 //        ParenLvl++;
 267 //        // allow positive lookahead to work
 268 //      }
 269 //      else if (sp.incMatch("{?="))
 270 //      {
 271 //        sb.append("(?=");
 272 //        ParenLvl++;
 273 //      }
 274 //      else if (sp.incMatch("{"))
 275 //      {
 276 //        sb.append("(?:");
 277 //        ParenLvl++;
 278 //      }
 279 //      else if (sp.incMatch("}"))
 280 //      {
 281 //        sb.append(')');
 282 //        ParenLvl--;
 283 //      }
 284 //      else if (ParenLvl != 0 && sp.incMatch(","))
 285 //      {
 286 //        sb.append('|');
 287 //      }
 288 //      else if (sp.incMatch("*"))
 289 //      {
 290 //        sb.append(".*");
 291 //      }
 292 //      else
 293 //      {
 294 //        sb.append(sp.thisChar());
 295 //        sp.inc();
 296 //      }
 297 //    }
 298 //    sb.append("$");
 299 //    return sb.toString();
 300 //  }
 301 //
 302 //  public boolean isLiteral()
 303 //  {
 304 //    Pattern x = thePattern;
 305 //    while (x != null && !(x instanceof End))
 306 //    {
 307 //      if (x instanceof oneChar)
 308 //      {
 309 //        ;
 310 //      }
 311 //      else if (x instanceof Skipped)
 312 //      {
 313 //        ;
 314 //      }
 315 //      else
 316 //      {
 317 //        return false;
 318 //      }
 319 //      x = x.next;
 320 //    }
 321 //    return true;
 322 //  }
 323 }