Back to index

wims  3.65+svn20090927
StringParser.java
Go to the documentation of this file.
00001 package rene.util.parser;
00002 
00003 import java.util.Vector;
00004 
00009 public class StringParser
00010 {      char C[];
00011        int N,L;
00012        boolean Error;
00013        
00017        public StringParser (String S)
00018        {      C=S.toCharArray();
00019               N=0;
00020               L=C.length;
00021               Error=(N>=L);
00022        }
00023 
00027        public boolean blank ()
00028        {      return (C[N]==' ' || C[N]=='\t' || C[N]=='\n' || C[N]=='\r');
00029        }
00030 
00034        public boolean blank (char c)
00035        {      return (C[N]==' ' || C[N]=='\t' || C[N]=='\n' || C[N]=='\r' || C[N]==c);
00036        }
00037 
00041        public String upto (char c)
00042        {      if (Error) return "";
00043               int n=N;
00044               while (n<L && C[n]!=c) n++;
00045               if (n>=L) Error=true;
00046               String s=new String(C,N,n-N);
00047               N=n;
00048               return s;
00049        }
00050 
00055        public boolean advance ()
00056        {      if (N<L) N++;
00057               if (N>=L) Error=true;
00058               return !Error;
00059        }
00060        
00064        public String parseword ()
00065        {      if (Error) return "";
00066               while (blank())
00067               {      if (!advance()) return "";
00068               }
00069               int n=N;
00070               while (!Error && !blank()) advance();
00071               return new String(C,n,N-n);
00072        }
00073 
00077        public String parsedigits (char c)
00078        {      if (Error) return "";
00079               while (blank())
00080               {      if (!advance()) return "";
00081               }
00082               int n=N;
00083               while (!Error && !blank())
00084               {      if (N>L || C[N]<'0' || C[N]>'9' || C[N]==c) break;
00085                      advance();
00086               }
00087               return new String(C,n,N-n);
00088        }
00089 
00093        public String parsedigits ()
00094        {      if (Error) return "";
00095               while (blank())
00096               {      if (!advance()) return "";
00097               }
00098               int n=N;
00099               while (!Error && !blank())
00100               {      if (N>L || C[N]<'0' || C[N]>'9') break;
00101                      advance();
00102               }
00103               return new String(C,n,N-n);
00104        }
00105 
00109        public String parseword (char c)
00110        {      if (Error) return "";
00111               while (blank())
00112               {      if (!advance()) return "";
00113               }
00114               int n=N;
00115               while (!Error && !blank(c)) advance();
00116               return new String(C,n,N-n);
00117        }
00118 
00122        public boolean isint ()
00123        {      if (Error) return false;
00124               return (C[N]>='0' && C[N]<='9');
00125        }
00126 
00131        public int parseint ()
00132        {      int sig=1;
00133               try
00134               {      skipblanks(); if (Error) return 0;
00135                      if (C[N]=='-')
00136                      {      sig=-1;
00137                             N++;
00138                             if (N>L) { Error=true; return 0; }
00139                      }
00140                      return sig*Integer.parseInt(parsedigits(),10);
00141               }
00142               catch (NumberFormatException e)
00143               {      return 0;
00144               }
00145        }
00146 
00151        public int parseint (char c)
00152        {      int sig=1;
00153               try
00154               {      skipblanks(); if (Error) return 0;
00155                      if (C[N]=='-')
00156                      {      sig=-1;
00157                             N++;
00158                             if (N>L) { Error=true; return 0; }
00159                      }
00160                      return sig*Integer.parseInt(parsedigits(c),10);
00161               }
00162               catch (NumberFormatException e)
00163               {      return 0;
00164               }
00165        }
00166 
00170        public void skipblanks ()
00171        {      if (Error) return;
00172               while (blank())
00173                      if (!advance()) break;
00174        }
00175 
00180        public boolean skip (String s)
00181        {      if (Error) return false;
00182               int l=s.length();
00183               if (N+l>L) return false;
00184               if (!new String(C,N,l).equals(s)) return false;
00185               N+=l;
00186               if (N>=L) Error=true;
00187               return true;
00188        }
00189 
00193        public char next ()
00194        {      if (Error) return ' ';
00195               else
00196               {      N++;
00197                      if (N>=L) { Error=true; }
00198                      return C[N-1];
00199               }
00200        }
00201 
00206        public String wrapline (int columns)
00207        {      int n=N,good=N;
00208               String s="";
00209               while (n<L)
00210               {      if (C[n]=='\n')
00211                      {      if (n>N) s=new String(C,N,n-N);
00212                             N=n+1;
00213                             break;
00214                      }
00215                      if (C[n]==' ' || C[n]=='\t' || C[n]=='\n')
00216                      {      good=n;
00217                      }
00218                      n++;
00219                      if (n-N>=columns && good>N)
00220                      {      s=new String(C,N,good-N);
00221                             N=good+1;
00222                             break;
00223                      }
00224                      if (n>=L)
00225                      {      if (n>N) s=new String(C,N,n-N);
00226                             N=n;
00227                             break;
00228                      }
00229               }
00230               if (N>=L) Error=true;
00231               return s;
00232        }
00233 
00239        public Vector wraplines (int columns)
00240        {      Vector v=new Vector(10,10);
00241               String s;
00242               while (!Error)
00243               {      s=wrapline(columns);
00244                      v.addElement(s);
00245               }
00246               return v;
00247        }
00248 
00249        public String wraplineword (int columns)
00250        {      int n=N,good=N;
00251               String s="";
00252               while (n<L)
00253               {      if (C[n]=='\n')
00254                      {      s=new String(C,N,n-N);
00255                             N=n+1;
00256                             break;
00257                      }
00258                      n++;
00259                      if (n>=L)
00260                      {      if (n>N) s=new String(C,N,n-N);
00261                             N=n;
00262                             break;
00263                      }
00264                      if (n-N>=columns && good>N)
00265                      {      s=new String(C,N,good-N);
00266                             N=good+1;
00267                             if (N<L && C[N]!='\n') s=s+"\\";
00268                             break;
00269                      }
00270               }
00271               if (N>=L) Error=true;
00272               return s;
00273        }
00274 
00275        public Vector wrapwords (int columns)
00276        {      Vector v=new Vector(10,10);
00277               String s;
00278               while (!Error)
00279               {      s=wraplineword(columns);
00280                      v.addElement(s);
00281               }
00282               return v;
00283        }
00284 
00288        public void replace(char c1, char c2)
00289        {      for (int i=0; i<L; i++)
00290                      if (C[i]==c1) C[i]=c2;
00291        }
00292 
00296        public boolean error () { return Error; }
00297 }