update to Jaba_r1 minimal client distribution, and resolve issues JAL-602
[jalview.git] / 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 }