unused/com/stevesoft/pat/RegexReader.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
  12 import com.stevesoft.pat.wrap.*;
  13
  14 /**
  15  * This class allows you to replace the text in strings as you read them in. Be
  16  * careful what you do with this freedom... using Regex.perlCode("s{.*}{x}s") as
  17  * your pattern will result in loading the entire contents of the Reader into
  18  * memory.
  19  */
  20 public class RegexReader extends Reader
  21 {
  22   RBuffer rb = new RBuffer(new javajs.util.SB());
  23
  24   PartialBuffer wrap = new PartialBuffer(rb.sb);
  25
  26   boolean moreToRead = true;
  27
  28   Reader r;
  29
  30   Replacer rp;
  31
  32   // the buffer size
  33   int nmax = 2 * 1024;
  34
  35   public RegexReader(Regex rex, Reader r)
  36   {
  37     this.r = r;
  38     rp = rex.getReplacer();
  39   }
  40
  41   public RegexReader(Transformer tex, Reader r)
  42   {
  43     this.r = r;
  44     rp = tex.getReplacer();
  45   }
  46
  47   public void reset() throws IOException
  48   {
  49     r.reset();
  50     rb = new RBuffer(new javajs.util.SB());
  51     wrap = new PartialBuffer(rb.sb);
  52     moreToRead = true;
  53   }
  54
  55   void readData() throws IOException
  56   {
  57     int c;
  58     int n = 0;
  59     while ((c = r.read()) != -1)
  60     {
  61       rb.sb.appendC((char) c);
  62       if (n++ > nmax)
  63       {
  64         break;
  65       }
  66     }
  67     if (c == -1 && n == 0)
  68     {
  69       moreToRead = false;
  70       wrap.allowOverRun = false;
  71     }
  72   }
  73
  74   void getMoreData() throws IOException
  75   {
  76     while (rb.pos >= rb.epos)
  77     {
  78       wrap.overRun = false;
  79       if (rb.next != null)
  80       {
  81         rb = rb.next;
  82       }
  83       else if (rb.done)
  84       {
  85         break;
  86       }
  87       else if (rb.epos >= rb.sb.length() && rb.epos > nmax)
  88       {
  89         rb.pos = 1;
  90         rb.epos = 1;
  91         rb.sb.setLength(1);
  92         readData();
  93       }
  94       else if (rb.epos >= rb.sb.length() && moreToRead)
  95       {
  96         readData();
  97       }
  98       else if (rp.getRegex().matchAt(wrap, rb.epos))
  99       {
 100         if (wrap.overRun)
 101         {
 102           readData();
 103         }
 104         else
 105         {
 106           StringBufferWrap sbw = new StringBufferWrap();
 107           StringBufferLike sbl = new StringBufferLike(sbw);
 108           /*
 109            * ReplaceRule rr = rex.getReplaceRule(); while(rr != null) {
 110            * rr.apply(sbl,rex); rr = rr.next; }
 111            */
 112           Regex rex = rp.getRegex();
 113           int npos = rex.matchedTo();
 114           rp.setBuffer(sbl);
 115           rp.setSource(wrap);
 116           rp.setPos(npos);
 117           rp.apply(rex, rex.getReplaceRule());
 118           int opos = rb.epos;
 119           RBuffer rb2 = new RBuffer((javajs.util.SB) sbw.unwrap());
 120           rb2.epos = rb2.sb.length();
 121           RBuffer rb3 = new RBuffer(rb.sb);
 122
 123           rb.next = rb2;
 124           rb2.next = rb3;
 125
 126           if (npos == opos)
 127           {
 128             rb3.epos = npos + 1;
 129             if (rb3.epos > rb3.sb.length())
 130             {
 131               if (rb.pos >= rb.epos)
 132               {
 133                 rb = rb.next;
 134               }
 135               rb3.pos = rb3.epos = 0;
 136               rb3.done = true;
 137               // break;
 138             }
 139             rb3.pos = npos;
 140           }
 141           else
 142           {
 143             rb3.pos = rb3.epos = npos;
 144           }
 145
 146         }
 147       }
 148       else
 149       {
 150         if (wrap.overRun)
 151         {
 152           readData();
 153         }
 154         else if (rb.epos < rb.sb.length())
 155         {
 156           rb.epos++;
 157         }
 158         else
 159         {
 160           break;
 161         }
 162       }
 163     }
 164   }
 165
 166   public int read() throws IOException
 167   {
 168     if (rb.pos >= rb.epos)
 169     {
 170       getMoreData();
 171       if (rb.pos >= rb.epos)
 172       {
 173         return -1;
 174       }
 175     }
 176     // System.out.println(rb);
 177     return rb.sb.charAt(rb.pos++);
 178   }
 179
 180   public int read(char[] buf, int off, int len) throws IOException
 181   {
 182     int c = -1;
 183     int end = off + len;
 184     for (int i = off; i < end; i++)
 185     {
 186       c = read();
 187       if (c < 0)
 188       {
 189         if (i == off)
 190         {
 191           return -1;
 192         }
 193         return i - off;
 194       }
 195       buf[i] = (char) c;
 196     }
 197     return len;
 198   }
 199
 200   public void close() throws IOException
 201   {
 202     r.close();
 203   }
 204
 205   public boolean markSupported()
 206   {
 207     return false;
 208   }
 209
 210   /**
 211    * Get the size of the working buffer. The current buffer may be larger if the
 212    * pattern demands it.
 213    */
 214   public int getBufferSize()
 215   {
 216     return nmax;
 217   }
 218
 219   /**
 220    * Set the size of the working buffer. The current buffer may be larger if the
 221    * pattern demands it.
 222    */
 223   public void setBufferSize(int n)
 224   {
 225     nmax = n;
 226   }
 227
 228   int max_lines = 2;
 229
 230   /**
 231    * This function no longer serves any purpose.
 232    *
 233    * @deprecated
 234    */
 235   public int getMaxLines()
 236   {
 237     return max_lines;
 238   }
 239
 240   /**
 241    * This function no longer serves any purpose.
 242    *
 243    * @deprecated
 244    */
 245   public void setMaxLines(int ml)
 246   {
 247     max_lines = ml;
 248   }
 249
 250   char EOLchar = '\n';
 251
 252   /**
 253    * This function no longer serves any purpose.
 254    *
 255    * @deprecated
 256    */
 257   public char getEOLchar()
 258   {
 259     return EOLchar;
 260   }
 261
 262   /**
 263    * This function no longer serves any purpose.
 264    *
 265    * @deprecated
 266    */
 267   public void setEOLchar(char c)
 268   {
 269     EOLchar = c;
 270   }
 271
 272   public long skip(long d) throws IOException
 273   {
 274     // This is probably inefficient, I just did it
 275     // this way to avoid possible bugs.
 276     long n = 0;
 277     while (n < d && read() != -1)
 278     {
 279       n++;
 280     }
 281     return n;
 282   }
 283
 284   /*
 285    * static void test(String re,String inp,int n) throws Exception { Reader r =
 286    * new StringReader(inp); r = new BufferedReader(r); Regex rex =
 287    * Regex.perlCode(re); String res1 = rex.replaceAll(inp); int c = -1;
 288    * javajs.util.SB sb = new javajs.util.SB(); RegexReader rr = new
 289    * RegexReader(rex,r); rr.setBufferSize(n); while( (c = rr.read()) != -1)
 290    * sb.append((char)c); String res2 = sb.toString(); if(!res1.equals(res2)) {
 291    * System.out.println("nmax="+n); System.out.println("re="+re);
 292    * System.out.println("inp="+inp); System.out.println("res1="+res1);
 293    * System.out.println("res2="+res2); System.exit(255); } } public static void
 294    * main(String[] args) throws Exception { for(int n=6;n<15;n++) {
 295    * test("s/x/y/","-----x123456789",n); test("s/x/y/","x123456789",n);
 296    * test("s/x/y/","-----x",n);
 297    * test("s/x.*?x/y/",".xx..x..x...x...x....x....x",n);
 298    * test("s/x.*x/[$&]/","--x........x--xx",n);
 299    * test("s/x.*x/[$&]/","--x........x------",n);
 300    * test("s/.$/a/m","bb\nbbb\nbbbb\nbbbbb\nbbbbbb\nbbbbbbbbbbbb",n);
 301    * test("s/.$/a/","123",n);
 302    * test("s/.$/a/","bb\nbbb\nbbbb\nbbbbb\nbbbbbb\nbb",n);
 303    * test("s/^./a/","bb\nbbb\nbbbb\nbbbbb\nbbbbbb\nbb",n);
 304    * test("s/$/a/","bbb",n); test("s/^/a/","bbb",n); test("s/^/a/","",n);
 305    * test("s{.*}{N}","xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",n);
 306    * test("s/.{0,7}/y/","AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",n);
 307    * test("s/x/$&/","xxx",n); } System.out.println("Success!!!"); }
 308    */
 309 }