-//\r
-// This software is now distributed according to\r
-// the Lesser Gnu Public License. Please see\r
-// http://www.gnu.org/copyleft/lesser.txt for\r
-// the details.\r
-// -- Happy Computing!\r
-//\r
-package com.stevesoft.pat;\r
-\r
-import java.io.*;\r
-\r
-import com.stevesoft.pat.wrap.*;\r
-\r
-/** This class allows you to replace the text in strings\r
- as you read them in. Be careful what you do with\r
- this freedom... using Regex.perlCode("s{.*}{x}s")\r
- as your pattern will result in loading the entire\r
- contents of the Reader into memory.\r
- */\r
-public class RegexReader\r
- extends Reader\r
-{\r
- RBuffer rb = new RBuffer(new StringBuffer());\r
- PartialBuffer wrap = new PartialBuffer(rb.sb);\r
- boolean moreToRead = true;\r
- Reader r;\r
- Replacer rp;\r
-\r
- // the buffer size\r
- int nmax = 2 * 1024;\r
-\r
- public RegexReader(Regex rex, Reader r)\r
- {\r
- this.r = r;\r
- rp = rex.getReplacer();\r
- }\r
-\r
- public RegexReader(Transformer tex, Reader r)\r
- {\r
- this.r = r;\r
- rp = tex.getReplacer();\r
- }\r
-\r
- public void reset()\r
- throws IOException\r
- {\r
- r.reset();\r
- rb = new RBuffer(new StringBuffer());\r
- wrap = new PartialBuffer(rb.sb);\r
- moreToRead = true;\r
- }\r
-\r
- void readData()\r
- throws IOException\r
- {\r
- int c;\r
- int n = 0;\r
- while ( (c = r.read()) != -1)\r
- {\r
- rb.sb.append( (char) c);\r
- if (n++ > nmax)\r
- {\r
- break;\r
- }\r
- }\r
- if (c == -1 && n == 0)\r
- {\r
- moreToRead = false;\r
- wrap.allowOverRun = false;\r
- }\r
- }\r
-\r
- void getMoreData()\r
- throws IOException\r
- {\r
- while (rb.pos >= rb.epos)\r
- {\r
- wrap.overRun = false;\r
- if (rb.next != null)\r
- {\r
- rb = rb.next;\r
- }\r
- else if (rb.done)\r
- {\r
- break;\r
- }\r
- else if (rb.epos >= rb.sb.length()\r
- && rb.epos > nmax)\r
- {\r
- rb.pos = 1;\r
- rb.epos = 1;\r
- rb.sb.setLength(1);\r
- readData();\r
- }\r
- else if (rb.epos >= rb.sb.length()\r
- && moreToRead)\r
- {\r
- readData();\r
- }\r
- else if (rp.getRegex().matchAt(wrap, rb.epos))\r
- {\r
- if (wrap.overRun)\r
- {\r
- readData();\r
- }\r
- else\r
- {\r
- StringBufferWrap sbw = new StringBufferWrap();\r
- StringBufferLike sbl = new StringBufferLike(sbw);\r
- /*\r
- ReplaceRule rr = rex.getReplaceRule();\r
- while(rr != null) {\r
- rr.apply(sbl,rex);\r
- rr = rr.next;\r
- }\r
- */\r
- Regex rex = rp.getRegex();\r
- int npos = rex.matchedTo();\r
- rp.setBuffer(sbl);\r
- rp.setSource(wrap);\r
- rp.setPos(npos);\r
- rp.apply(rex, rex.getReplaceRule());\r
- int opos = rb.epos;\r
- RBuffer rb2 = new RBuffer( (StringBuffer) sbw.unwrap());\r
- rb2.epos = rb2.sb.length();\r
- RBuffer rb3 = new RBuffer(rb.sb);\r
-\r
- rb.next = rb2;\r
- rb2.next = rb3;\r
-\r
- if (npos == opos)\r
- {\r
- rb3.epos = npos + 1;\r
- if (rb3.epos > rb3.sb.length())\r
- {\r
- if (rb.pos >= rb.epos)\r
- {\r
- rb = rb.next;\r
- }\r
- rb3.pos = rb3.epos = 0;\r
- rb3.done = true;\r
- //break;\r
- }\r
- rb3.pos = npos;\r
- }\r
- else\r
- {\r
- rb3.pos = rb3.epos = npos;\r
- }\r
-\r
- }\r
- }\r
- else\r
- {\r
- if (wrap.overRun)\r
- {\r
- readData();\r
- }\r
- else if (rb.epos < rb.sb.length())\r
- {\r
- rb.epos++;\r
- }\r
- else\r
- {\r
- break;\r
- }\r
- }\r
- }\r
- }\r
-\r
- public int read()\r
- throws IOException\r
- {\r
- if (rb.pos >= rb.epos)\r
- {\r
- getMoreData();\r
- if (rb.pos >= rb.epos)\r
- {\r
- return -1;\r
- }\r
- }\r
- //System.out.println(rb);\r
- return rb.sb.charAt(rb.pos++);\r
- }\r
-\r
- public int read(char[] buf, int off, int len)\r
- throws IOException\r
- {\r
- int c = -1;\r
- int end = off + len;\r
- for (int i = off; i < end; i++)\r
- {\r
- c = read();\r
- if (c < 0)\r
- {\r
- if (i == off)\r
- {\r
- return -1;\r
- }\r
- return i - off;\r
- }\r
- buf[i] = (char) c;\r
- }\r
- return len;\r
- }\r
-\r
- public void close()\r
- throws IOException\r
- {\r
- r.close();\r
- }\r
-\r
- public boolean markSupported()\r
- {\r
- return false;\r
- }\r
-\r
- /** Get the size of the working buffer.\r
- The current buffer may be larger if\r
- the pattern demands it. */\r
- public int getBufferSize()\r
- {\r
- return nmax;\r
- }\r
-\r
- /** Set the size of the working buffer.\r
- The current buffer may be larger if\r
- the pattern demands it. */\r
- public void setBufferSize(int n)\r
- {\r
- nmax = n;\r
- }\r
-\r
- int max_lines = 2;\r
- /** This function no longer serves any purpose.\r
- @deprecated\r
- */\r
- public int getMaxLines()\r
- {\r
- return max_lines;\r
- }\r
-\r
- /** This function no longer serves any purpose.\r
- @deprecated\r
- */\r
- public void setMaxLines(int ml)\r
- {\r
- max_lines = ml;\r
- }\r
-\r
- char EOLchar = '\n';\r
- /** This function no longer serves any purpose.\r
- @deprecated\r
- */\r
- public char getEOLchar()\r
- {\r
- return EOLchar;\r
- }\r
-\r
- /** This function no longer serves any purpose.\r
- @deprecated\r
- */\r
- public void setEOLchar(char c)\r
- {\r
- EOLchar = c;\r
- }\r
-\r
- public long skip(long d)\r
- throws IOException\r
- {\r
- // This is probably inefficient, I just did it\r
- // this way to avoid possible bugs.\r
- long n = 0;\r
- while (n < d && read() != -1)\r
- {\r
- n++;\r
- }\r
- return n;\r
- }\r
-\r
- /*\r
- static void test(String re,String inp,int n) throws Exception {\r
- Reader r = new StringReader(inp);\r
- r = new BufferedReader(r);\r
- Regex rex = Regex.perlCode(re);\r
- String res1 = rex.replaceAll(inp);\r
- int c = -1;\r
- StringBuffer sb = new StringBuffer();\r
- RegexReader rr = new RegexReader(rex,r);\r
- rr.setBufferSize(n);\r
- while( (c = rr.read()) != -1)\r
- sb.append((char)c);\r
- String res2 = sb.toString();\r
- if(!res1.equals(res2)) {\r
- System.out.println("nmax="+n);\r
- System.out.println("re="+re);\r
- System.out.println("inp="+inp);\r
- System.out.println("res1="+res1);\r
- System.out.println("res2="+res2);\r
- System.exit(255);\r
- }\r
- }\r
- public static void main(String[] args) throws Exception {\r
- for(int n=6;n<15;n++) {\r
- test("s/x/y/","-----x123456789",n);\r
- test("s/x/y/","x123456789",n);\r
- test("s/x/y/","-----x",n);\r
- test("s/x.*?x/y/",".xx..x..x...x...x....x....x",n);\r
- test("s/x.*x/[$&]/","--x........x--xx",n);\r
- test("s/x.*x/[$&]/","--x........x------",n);\r
- test("s/.$/a/m","bb\nbbb\nbbbb\nbbbbb\nbbbbbb\nbbbbbbbbbbbb",n);\r
- test("s/.$/a/","123",n);\r
- test("s/.$/a/","bb\nbbb\nbbbb\nbbbbb\nbbbbbb\nbb",n);\r
- test("s/^./a/","bb\nbbb\nbbbb\nbbbbb\nbbbbbb\nbb",n);\r
- test("s/$/a/","bbb",n);\r
- test("s/^/a/","bbb",n);\r
- test("s/^/a/","",n);\r
- test("s{.*}{N}","xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",n);\r
- test("s/.{0,7}/y/","AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",n);\r
- test("s/x/$&/","xxx",n);\r
- }\r
- System.out.println("Success!!!");\r
- }\r
- */\r
-}\r
+//
+// This software is now distributed according to
+// the Lesser Gnu Public License. Please see
+// http://www.gnu.org/copyleft/lesser.txt for
+// the details.
+// -- Happy Computing!
+//
+package com.stevesoft.pat;
+
+import java.io.*;
+
+import com.stevesoft.pat.wrap.*;
+
+/**
+ * This class allows you to replace the text in strings as you read them in. Be
+ * careful what you do with this freedom... using Regex.perlCode("s{.*}{x}s") as
+ * your pattern will result in loading the entire contents of the Reader into
+ * memory.
+ */
+public class RegexReader extends Reader
+{
+ RBuffer rb = new RBuffer(new StringBuffer());
+
+ PartialBuffer wrap = new PartialBuffer(rb.sb);
+
+ boolean moreToRead = true;
+
+ Reader r;
+
+ Replacer rp;
+
+ // the buffer size
+ int nmax = 2 * 1024;
+
+ public RegexReader(Regex rex, Reader r)
+ {
+ this.r = r;
+ rp = rex.getReplacer();
+ }
+
+ public RegexReader(Transformer tex, Reader r)
+ {
+ this.r = r;
+ rp = tex.getReplacer();
+ }
+
+ public void reset() throws IOException
+ {
+ r.reset();
+ rb = new RBuffer(new StringBuffer());
+ wrap = new PartialBuffer(rb.sb);
+ moreToRead = true;
+ }
+
+ void readData() throws IOException
+ {
+ int c;
+ int n = 0;
+ while ((c = r.read()) != -1)
+ {
+ rb.sb.append((char) c);
+ if (n++ > nmax)
+ {
+ break;
+ }
+ }
+ if (c == -1 && n == 0)
+ {
+ moreToRead = false;
+ wrap.allowOverRun = false;
+ }
+ }
+
+ void getMoreData() throws IOException
+ {
+ while (rb.pos >= rb.epos)
+ {
+ wrap.overRun = false;
+ if (rb.next != null)
+ {
+ rb = rb.next;
+ }
+ else if (rb.done)
+ {
+ break;
+ }
+ else if (rb.epos >= rb.sb.length() && rb.epos > nmax)
+ {
+ rb.pos = 1;
+ rb.epos = 1;
+ rb.sb.setLength(1);
+ readData();
+ }
+ else if (rb.epos >= rb.sb.length() && moreToRead)
+ {
+ readData();
+ }
+ else if (rp.getRegex().matchAt(wrap, rb.epos))
+ {
+ if (wrap.overRun)
+ {
+ readData();
+ }
+ else
+ {
+ StringBufferWrap sbw = new StringBufferWrap();
+ StringBufferLike sbl = new StringBufferLike(sbw);
+ /*
+ * ReplaceRule rr = rex.getReplaceRule(); while(rr != null) {
+ * rr.apply(sbl,rex); rr = rr.next; }
+ */
+ Regex rex = rp.getRegex();
+ int npos = rex.matchedTo();
+ rp.setBuffer(sbl);
+ rp.setSource(wrap);
+ rp.setPos(npos);
+ rp.apply(rex, rex.getReplaceRule());
+ int opos = rb.epos;
+ RBuffer rb2 = new RBuffer((StringBuffer) sbw.unwrap());
+ rb2.epos = rb2.sb.length();
+ RBuffer rb3 = new RBuffer(rb.sb);
+
+ rb.next = rb2;
+ rb2.next = rb3;
+
+ if (npos == opos)
+ {
+ rb3.epos = npos + 1;
+ if (rb3.epos > rb3.sb.length())
+ {
+ if (rb.pos >= rb.epos)
+ {
+ rb = rb.next;
+ }
+ rb3.pos = rb3.epos = 0;
+ rb3.done = true;
+ // break;
+ }
+ rb3.pos = npos;
+ }
+ else
+ {
+ rb3.pos = rb3.epos = npos;
+ }
+
+ }
+ }
+ else
+ {
+ if (wrap.overRun)
+ {
+ readData();
+ }
+ else if (rb.epos < rb.sb.length())
+ {
+ rb.epos++;
+ }
+ else
+ {
+ break;
+ }
+ }
+ }
+ }
+
+ public int read() throws IOException
+ {
+ if (rb.pos >= rb.epos)
+ {
+ getMoreData();
+ if (rb.pos >= rb.epos)
+ {
+ return -1;
+ }
+ }
+ // System.out.println(rb);
+ return rb.sb.charAt(rb.pos++);
+ }
+
+ public int read(char[] buf, int off, int len) throws IOException
+ {
+ int c = -1;
+ int end = off + len;
+ for (int i = off; i < end; i++)
+ {
+ c = read();
+ if (c < 0)
+ {
+ if (i == off)
+ {
+ return -1;
+ }
+ return i - off;
+ }
+ buf[i] = (char) c;
+ }
+ return len;
+ }
+
+ public void close() throws IOException
+ {
+ r.close();
+ }
+
+ public boolean markSupported()
+ {
+ return false;
+ }
+
+ /**
+ * Get the size of the working buffer. The current buffer may be larger if the
+ * pattern demands it.
+ */
+ public int getBufferSize()
+ {
+ return nmax;
+ }
+
+ /**
+ * Set the size of the working buffer. The current buffer may be larger if the
+ * pattern demands it.
+ */
+ public void setBufferSize(int n)
+ {
+ nmax = n;
+ }
+
+ int max_lines = 2;
+
+ /**
+ * This function no longer serves any purpose.
+ *
+ * @deprecated
+ */
+ public int getMaxLines()
+ {
+ return max_lines;
+ }
+
+ /**
+ * This function no longer serves any purpose.
+ *
+ * @deprecated
+ */
+ public void setMaxLines(int ml)
+ {
+ max_lines = ml;
+ }
+
+ char EOLchar = '\n';
+
+ /**
+ * This function no longer serves any purpose.
+ *
+ * @deprecated
+ */
+ public char getEOLchar()
+ {
+ return EOLchar;
+ }
+
+ /**
+ * This function no longer serves any purpose.
+ *
+ * @deprecated
+ */
+ public void setEOLchar(char c)
+ {
+ EOLchar = c;
+ }
+
+ public long skip(long d) throws IOException
+ {
+ // This is probably inefficient, I just did it
+ // this way to avoid possible bugs.
+ long n = 0;
+ while (n < d && read() != -1)
+ {
+ n++;
+ }
+ return n;
+ }
+
+ /*
+ * static void test(String re,String inp,int n) throws Exception { Reader r =
+ * new StringReader(inp); r = new BufferedReader(r); Regex rex =
+ * Regex.perlCode(re); String res1 = rex.replaceAll(inp); int c = -1;
+ * StringBuffer sb = new StringBuffer(); RegexReader rr = new
+ * RegexReader(rex,r); rr.setBufferSize(n); while( (c = rr.read()) != -1)
+ * sb.append((char)c); String res2 = sb.toString(); if(!res1.equals(res2)) {
+ * System.out.println("nmax="+n); System.out.println("re="+re);
+ * System.out.println("inp="+inp); System.out.println("res1="+res1);
+ * System.out.println("res2="+res2); System.exit(255); } } public static void
+ * main(String[] args) throws Exception { for(int n=6;n<15;n++) {
+ * test("s/x/y/","-----x123456789",n); test("s/x/y/","x123456789",n);
+ * test("s/x/y/","-----x",n);
+ * test("s/x.*?x/y/",".xx..x..x...x...x....x....x",n);
+ * test("s/x.*x/[$&]/","--x........x--xx",n);
+ * test("s/x.*x/[$&]/","--x........x------",n);
+ * test("s/.$/a/m","bb\nbbb\nbbbb\nbbbbb\nbbbbbb\nbbbbbbbbbbbb",n);
+ * test("s/.$/a/","123",n);
+ * test("s/.$/a/","bb\nbbb\nbbbb\nbbbbb\nbbbbbb\nbb",n);
+ * test("s/^./a/","bb\nbbb\nbbbb\nbbbbb\nbbbbbb\nbb",n);
+ * test("s/$/a/","bbb",n); test("s/^/a/","bbb",n); test("s/^/a/","",n);
+ * test("s{.*}{N}","xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",n);
+ * test("s/.{0,7}/y/","AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",n);
+ * test("s/x/$&/","xxx",n); } System.out.println("Success!!!"); }
+ */
+}
git://source.jalview.org / jalview.git / blobdiff