jvanzyl 02/03/03 20:53:33
Modified: src/java/org/apache/maven/jrcs/rcs ArchiveParser.java
ArchiveParserTokenManager.java
Added: src/java/org/apache/maven/jrcs/rcs JavaCharStream.java
Log:
Adding in the generated JavaCharStream. Jaun, I just generated myself so
I don't think we bonked anything. We just wanted to build :-)
Revision Changes Path
1.10 +438 -273
jakarta-turbine-maven/src/java/org/apache/maven/jrcs/rcs/ArchiveParser.java
Index: ArchiveParser.java
===================================================================
RCS file:
/home/cvs/jakarta-turbine-maven/src/java/org/apache/maven/jrcs/rcs/ArchiveParser.java,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -r1.9 -r1.10
--- ArchiveParser.java 3 Mar 2002 22:14:20 -0000 1.9
+++ ArchiveParser.java 4 Mar 2002 04:53:32 -0000 1.10
@@ -11,7 +11,7 @@
* This class is NOT thread safe.
*
* @author <a href="mailto:[EMAIL PROTECTED]";>Juanco Anez</a>
- * @version $Id: ArchiveParser.java,v 1.9 2002/03/03 22:14:20 juanco Exp $
+ * @version $Id: ArchiveParser.java,v 1.10 2002/03/04 04:53:32 jvanzyl Exp $
* @see Archive
*/
class ArchiveParser implements ArchiveParserConstants {
@@ -77,442 +77,562 @@
* PARSER STARTS HERE
*/
final public void archive(Archive arc) throws ParseException {
- admin(arc);
- label_1:
- while (true) {
- switch (jj_nt.kind) {
- case NUM:
- ;
- break;
- default:
- break label_1;
- }
- delta(arc);
+ trace_call("archive");
+ try {
+ admin(arc);
+ label_1:
+ while (true) {
+ switch (jj_nt.kind) {
+ case NUM:
+ ;
+ break;
+ default:
+ break label_1;
+ }
+ delta(arc);
+ }
+ desc(arc);
+ label_2:
+ while (true) {
+ switch (jj_nt.kind) {
+ case NUM:
+ ;
+ break;
+ default:
+ break label_2;
+ }
+ text(arc);
+ }
+ jj_consume_token(0);
+ } finally {
+ trace_return("archive");
}
- desc(arc);
- label_2:
- while (true) {
+ }
+
+ final public void admin(Archive arc) throws ParseException {
+ trace_call("admin");
+ try {
+ head(arc);
switch (jj_nt.kind) {
- case NUM:
- ;
+ case BRANCH:
+ branch(arc);
break;
default:
- break label_2;
+ ;
}
- text(arc);
+ access(arc);
+ symbols(arc);
+ locks(arc);
+ optionals(arc);
+ } finally {
+ trace_return("admin");
}
- jj_consume_token(0);
- }
-
- final public void admin(Archive arc) throws ParseException {
- head(arc);
- switch (jj_nt.kind) {
- case BRANCH:
- branch(arc);
- break;
- default:
- ;
- }
- access(arc);
- symbols(arc);
- locks(arc);
- optionals(arc);
}
final public void optionals(Archive arc) throws ParseException {
- label_3:
- while (true) {
- switch (jj_nt.kind) {
- case COMMENT:
- case EXPAND:
- case ID:
- ;
- break;
- default:
- break label_3;
- }
- switch (jj_nt.kind) {
- case COMMENT:
- comment(arc);
- break;
- case EXPAND:
- expand(arc);
- break;
- case ID:
- newPhrase(arc.phrases);
- break;
- default:
- jj_consume_token(-1);
- throw new ParseException();
+ trace_call("optionals");
+ try {
+ label_3:
+ while (true) {
+ switch (jj_nt.kind) {
+ case COMMENT:
+ case EXPAND:
+ case ID:
+ ;
+ break;
+ default:
+ break label_3;
+ }
+ switch (jj_nt.kind) {
+ case COMMENT:
+ comment(arc);
+ break;
+ case EXPAND:
+ expand(arc);
+ break;
+ case ID:
+ newPhrase(arc.phrases);
+ break;
+ default:
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
}
+ } finally {
+ trace_return("optionals");
}
}
final public void newPhrases(Map map) throws ParseException {
- label_4:
- while (true) {
- switch (jj_nt.kind) {
- case ID:
- ;
- break;
- default:
- break label_4;
+ trace_call("newPhrases");
+ try {
+ label_4:
+ while (true) {
+ switch (jj_nt.kind) {
+ case ID:
+ ;
+ break;
+ default:
+ break label_4;
+ }
+ newPhrase(map);
}
- newPhrase(map);
+ } finally {
+ trace_return("newPhrases");
}
}
final public void head(Archive arc) throws ParseException {
+ trace_call("head");
+ try {
Version v;
- jj_consume_token(HEAD);
- switch (jj_nt.kind) {
- case NUM:
- v = version();
+ jj_consume_token(HEAD);
+ switch (jj_nt.kind) {
+ case NUM:
+ v = version();
arc.setHead(v);
- break;
- default:
- ;
+ break;
+ default:
+ ;
+ }
+ jj_consume_token(29);
+ } finally {
+ trace_return("head");
}
- jj_consume_token(29);
}
final public void branch(Archive arc) throws ParseException {
+ trace_call("branch");
+ try {
Version v;
- jj_consume_token(BRANCH);
- switch (jj_nt.kind) {
- case NUM:
- v = version();
+ jj_consume_token(BRANCH);
+ switch (jj_nt.kind) {
+ case NUM:
+ v = version();
arc.setBranch(v);
- break;
- default:
- ;
+ break;
+ default:
+ ;
+ }
+ jj_consume_token(29);
+ } finally {
+ trace_return("branch");
}
- jj_consume_token(29);
}
final public void access(Archive arc) throws ParseException {
+ trace_call("access");
+ try {
String name;
- jj_consume_token(ACCESS);
- label_5:
- while (true) {
- switch (jj_nt.kind) {
- case ID:
- ;
- break;
- default:
- break label_5;
- }
- name = id();
+ jj_consume_token(ACCESS);
+ label_5:
+ while (true) {
+ switch (jj_nt.kind) {
+ case ID:
+ ;
+ break;
+ default:
+ break label_5;
+ }
+ name = id();
arc.addUser(name);
+ }
+ jj_consume_token(29);
+ } finally {
+ trace_return("access");
}
- jj_consume_token(29);
}
final public void symbols(Archive arc) throws ParseException {
+ trace_call("symbols");
+ try {
String s;
Version v;
- jj_consume_token(SYMBOLS);
- label_6:
- while (true) {
- switch (jj_nt.kind) {
- case ID:
- case SYM:
- ;
- break;
- default:
- break label_6;
- }
- s = sym();
- jj_consume_token(30);
- v = version();
+ jj_consume_token(SYMBOLS);
+ label_6:
+ while (true) {
+ switch (jj_nt.kind) {
+ case ID:
+ case SYM:
+ ;
+ break;
+ default:
+ break label_6;
+ }
+ s = sym();
+ jj_consume_token(30);
+ v = version();
arc.addSymbol(s, v);
+ }
+ jj_consume_token(29);
+ } finally {
+ trace_return("symbols");
}
- jj_consume_token(29);
}
final public void locks(Archive arc) throws ParseException {
+ trace_call("locks");
+ try {
String name;
Version v;
- jj_consume_token(LOCKS);
- label_7:
- while (true) {
+ jj_consume_token(LOCKS);
+ label_7:
+ while (true) {
+ switch (jj_nt.kind) {
+ case ID:
+ ;
+ break;
+ default:
+ break label_7;
+ }
+ name = id();
+ jj_consume_token(30);
+ v = version();
+ arc.addLock(name, v);
+ }
+ jj_consume_token(29);
switch (jj_nt.kind) {
- case ID:
- ;
+ case STRICT:
+ jj_consume_token(STRICT);
+ jj_consume_token(29);
+ arc.setStrictLocking(true);
break;
default:
- break label_7;
+ ;
}
- name = id();
- jj_consume_token(30);
- v = version();
- arc.addLock(name, v);
- }
- jj_consume_token(29);
- switch (jj_nt.kind) {
- case STRICT:
- jj_consume_token(STRICT);
- jj_consume_token(29);
- arc.setStrictLocking(true);
- break;
- default:
- ;
+ } finally {
+ trace_return("locks");
}
}
final public void comment(Archive arc) throws ParseException {
+ trace_call("comment");
+ try {
String s;
- jj_consume_token(COMMENT);
- switch (jj_nt.kind) {
- case STRING:
- s = string();
+ jj_consume_token(COMMENT);
+ switch (jj_nt.kind) {
+ case STRING:
+ s = string();
arc.setComment(s);
- break;
- default:
- ;
+ break;
+ default:
+ ;
+ }
+ jj_consume_token(29);
+ } finally {
+ trace_return("comment");
}
- jj_consume_token(29);
}
final public void expand(Archive arc) throws ParseException {
+ trace_call("expand");
+ try {
String s;
- jj_consume_token(EXPAND);
- switch (jj_nt.kind) {
- case STRING:
- s = string();
+ jj_consume_token(EXPAND);
+ switch (jj_nt.kind) {
+ case STRING:
+ s = string();
arc.setExpand(s);
- break;
- default:
- ;
+ break;
+ default:
+ ;
+ }
+ jj_consume_token(29);
+ } finally {
+ trace_return("expand");
}
- jj_consume_token(29);
}
final public void newPhrase(Map map) throws ParseException {
+ trace_call("newPhrase");
+ try {
String key;
String value;
StringBuffer values = new StringBuffer();
- key = id();
- label_8:
- while (true) {
- switch (jj_nt.kind) {
- case ID:
- case STRING:
- case NUM:
- ;
- break;
- default:
- break label_8;
- }
- value = word();
+ key = id();
+ label_8:
+ while (true) {
+ switch (jj_nt.kind) {
+ case ID:
+ case STRING:
+ case NUM:
+ ;
+ break;
+ default:
+ break label_8;
+ }
+ value = word();
values.append(" " + value);
- }
- jj_consume_token(29);
+ }
+ jj_consume_token(29);
if (map != null) map.put(key, values.toString());
+ } finally {
+ trace_return("newPhrase");
+ }
}
final public String word() throws ParseException {
+ trace_call("word");
+ try {
String result;
- if (jj_2_1(2)) {
- result = pair();
- } else {
- switch (jj_nt.kind) {
- case ID:
- case STRING:
- case NUM:
- result = simpleWord();
- break;
- default:
- jj_consume_token(-1);
- throw new ParseException();
+ if (jj_2_1(2)) {
+ result = pair();
+ } else {
+ switch (jj_nt.kind) {
+ case ID:
+ case STRING:
+ case NUM:
+ result = simpleWord();
+ break;
+ default:
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
}
- }
{if (true) return result;}
throw new Error("Missing return statement in function");
+ } finally {
+ trace_return("word");
+ }
}
final public String simpleWord() throws ParseException {
+ trace_call("simpleWord");
+ try {
String result;
Version v;
- switch (jj_nt.kind) {
- case ID:
- result = id();
- break;
- case NUM:
- v = version();
+ switch (jj_nt.kind) {
+ case ID:
+ result = id();
+ break;
+ case NUM:
+ v = version();
result = v.toString();
- break;
- case STRING:
- result = string();
- break;
- default:
- jj_consume_token(-1);
- throw new ParseException();
- }
+ break;
+ case STRING:
+ result = string();
+ break;
+ default:
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
{if (true) return result;}
throw new Error("Missing return statement in function");
+ } finally {
+ trace_return("simpleWord");
+ }
}
final public String pair() throws ParseException {
+ trace_call("pair");
+ try {
String left;
String right;
- left = simpleWord();
- jj_consume_token(30);
- right = simpleWord();
+ left = simpleWord();
+ jj_consume_token(30);
+ right = simpleWord();
{if (true) return left + ":" + right;}
throw new Error("Missing return statement in function");
+ } finally {
+ trace_return("pair");
+ }
}
final public void desc(Archive arc) throws ParseException {
+ trace_call("desc");
+ try {
String s;
- jj_consume_token(DESC);
- s = string();
+ jj_consume_token(DESC);
+ s = string();
arc.setDesc(s);
+ } finally {
+ trace_return("desc");
+ }
}
final public void delta(Archive arc) throws ParseException {
+ trace_call("delta");
+ try {
Version v;
Node node;
int[] d;
String s;
- v = version();
+ v = version();
node = arc.newNode(v);
- jj_consume_token(DATE);
- d = date();
+ jj_consume_token(DATE);
+ d = date();
node.setDate(d);
- jj_consume_token(29);
- jj_consume_token(AUTHOR);
- s = id();
- node.setAuthor(s);
- jj_consume_token(29);
- jj_consume_token(STATE);
- switch (jj_nt.kind) {
- case ID:
+ jj_consume_token(29);
+ jj_consume_token(AUTHOR);
s = id();
- node.setState(s);
- break;
- default:
- ;
- }
- jj_consume_token(29);
- jj_consume_token(BRANCHES);
- label_9:
- while (true) {
+ node.setAuthor(s);
+ jj_consume_token(29);
+ jj_consume_token(STATE);
switch (jj_nt.kind) {
- case NUM:
- ;
+ case ID:
+ s = id();
+ node.setState(s);
break;
default:
- break label_9;
+ ;
}
- v = version();
+ jj_consume_token(29);
+ jj_consume_token(BRANCHES);
+ label_9:
+ while (true) {
+ switch (jj_nt.kind) {
+ case NUM:
+ ;
+ break;
+ default:
+ break label_9;
+ }
+ v = version();
node.addBranch(arc.newBranchNode(v));
- }
- jj_consume_token(29);
- jj_consume_token(NEXT);
- switch (jj_nt.kind) {
- case NUM:
- v = version();
+ }
+ jj_consume_token(29);
+ jj_consume_token(NEXT);
+ switch (jj_nt.kind) {
+ case NUM:
+ v = version();
node.setRCSNext(arc.newNode(v));
- break;
- default:
- ;
+ break;
+ default:
+ ;
+ }
+ jj_consume_token(29);
+ newPhrases(node.phrases);
+ } finally {
+ trace_return("delta");
}
- jj_consume_token(29);
- newPhrases(node.phrases);
}
final public void text(Archive arc) throws ParseException {
+ trace_call("text");
+ try {
Version v;
Node node;
String log;
String txt;
- v = version();
+ v = version();
node = arc.getNode(v);
- jj_consume_token(LOG);
- log = string();
+ jj_consume_token(LOG);
+ log = string();
node.setLog(log);
- newPhrases(node.phrases);
- jj_consume_token(TEXT);
- txt = string();
+ newPhrases(node.phrases);
+ jj_consume_token(TEXT);
+ txt = string();
node.setText(txt);
+ } finally {
+ trace_return("text");
+ }
}
final public String id() throws ParseException {
+ trace_call("id");
+ try {
Token t;
- t = jj_consume_token(ID);
+ t = jj_consume_token(ID);
{if (true) return t.image;}
throw new Error("Missing return statement in function");
+ } finally {
+ trace_return("id");
+ }
}
final public String sym() throws ParseException {
+ trace_call("sym");
+ try {
Token t;
- switch (jj_nt.kind) {
- case SYM:
- t = jj_consume_token(SYM);
- break;
- case ID:
- t = jj_consume_token(ID);
- break;
- default:
- jj_consume_token(-1);
- throw new ParseException();
- }
+ switch (jj_nt.kind) {
+ case SYM:
+ t = jj_consume_token(SYM);
+ break;
+ case ID:
+ t = jj_consume_token(ID);
+ break;
+ default:
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
{if (true) return t.image;}
throw new Error("Missing return statement in function");
+ } finally {
+ trace_return("sym");
+ }
}
final public Version version() throws ParseException {
+ trace_call("version");
+ try {
Version v;
int n, r;
- n = num();
- v = new Version(n);
- label_10:
- while (true) {
- switch (jj_nt.kind) {
- case 31:
- ;
- break;
- default:
- break label_10;
- }
- jj_consume_token(31);
n = num();
+ v = new Version(n);
+ label_10:
+ while (true) {
+ switch (jj_nt.kind) {
+ case 31:
+ ;
+ break;
+ default:
+ break label_10;
+ }
+ jj_consume_token(31);
+ n = num();
v.__addBranch(n);
- }
+ }
{if (true) return v;}
throw new Error("Missing return statement in function");
+ } finally {
+ trace_return("version");
+ }
}
final public int[] date() throws ParseException {
+ trace_call("date");
+ try {
int[] n = new int[6];
- n[0] = num();
- jj_consume_token(31);
- n[1] = num();
- jj_consume_token(31);
- n[2] = num();
- jj_consume_token(31);
- n[3] = num();
- jj_consume_token(31);
- n[4] = num();
- jj_consume_token(31);
- n[5] = num();
+ n[0] = num();
+ jj_consume_token(31);
+ n[1] = num();
+ jj_consume_token(31);
+ n[2] = num();
+ jj_consume_token(31);
+ n[3] = num();
+ jj_consume_token(31);
+ n[4] = num();
+ jj_consume_token(31);
+ n[5] = num();
{if (true) return n;}
throw new Error("Missing return statement in function");
+ } finally {
+ trace_return("date");
+ }
}
final public int num() throws ParseException {
+ trace_call("num");
+ try {
Token t;
- t = jj_consume_token(NUM);
+ t = jj_consume_token(NUM);
{if (true) return Integer.parseInt(t.image);}
throw new Error("Missing return statement in function");
+ } finally {
+ trace_return("num");
+ }
}
final public String string() throws ParseException {
+ trace_call("string");
+ try {
Token t;
- t = jj_consume_token(STRING);
+ t = jj_consume_token(STRING);
{if (true) return Archive.unquoteString(t.image);}
throw new Error("Missing return statement in function");
+ } finally {
+ trace_return("string");
+ }
}
final private boolean jj_2_1(int xla) {
@@ -655,6 +775,7 @@
if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
else jj_nt = jj_nt.next = token_source.getNextToken();
if (token.kind == kind) {
+ trace_token(token, "");
return token;
}
jj_nt = token;
@@ -679,6 +800,7 @@
final public Token getNextToken() {
if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
else jj_nt = jj_nt.next = token_source.getNextToken();
+ trace_token(token, " (in getNextToken)");
return token;
}
@@ -698,10 +820,53 @@
return new ParseException("Parse error at line " + line + ", column " + column
+ ". Encountered: " + mess);
}
+ private int trace_indent = 0;
+ private boolean trace_enabled = true;
+
final public void enable_tracing() {
+ trace_enabled = true;
}
final public void disable_tracing() {
+ trace_enabled = false;
+ }
+
+ final private void trace_call(String s) {
+ if (trace_enabled) {
+ for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+ System.out.println("Call: " + s);
+ }
+ trace_indent = trace_indent + 2;
+ }
+
+ final private void trace_return(String s) {
+ trace_indent = trace_indent - 2;
+ if (trace_enabled) {
+ for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+ System.out.println("Return: " + s);
+ }
+ }
+
+ final private void trace_token(Token t, String where) {
+ if (trace_enabled) {
+ for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+ System.out.print("Consumed token: <" + tokenImage[t.kind]);
+ if (t.kind != 0 && !tokenImage[t.kind].equals("\"" + t.image + "\"")) {
+ System.out.print(": \"" + t.image + "\"");
+ }
+ System.out.println(">" + where);
+ }
+ }
+
+ final private void trace_scan(Token t1, int t2) {
+ if (trace_enabled) {
+ for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+ System.out.print("Visited token: <" + tokenImage[t1.kind]);
+ if (t1.kind != 0 && !tokenImage[t1.kind].equals("\"" + t1.image + "\"")) {
+ System.out.print(": \"" + t1.image + "\"");
+ }
+ System.out.println(">; Expected token: <" + tokenImage[t2] + ">");
+ }
}
}
1.5 +166 -0
jakarta-turbine-maven/src/java/org/apache/maven/jrcs/rcs/ArchiveParserTokenManager.java
Index: ArchiveParserTokenManager.java
===================================================================
RCS file:
/home/cvs/jakarta-turbine-maven/src/java/org/apache/maven/jrcs/rcs/ArchiveParserTokenManager.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- ArchiveParserTokenManager.java 3 Mar 2002 22:14:20 -0000 1.4
+++ ArchiveParserTokenManager.java 4 Mar 2002 04:53:32 -0000 1.5
@@ -11,6 +11,7 @@
public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
private final int jjStopStringLiteralDfa_0(int pos, long active0)
{
+ debugStream.println(" No more string literal token matches are possible.");
switch (pos)
{
case 0:
@@ -93,14 +94,19 @@
{
jjmatchedKind = kind;
jjmatchedPos = pos;
+ debugStream.println(" No more string literal token matches are possible.");
+ debugStream.println(" Currently matched the first " + (jjmatchedPos + 1) + "
characters as a " + tokenImage[jjmatchedKind] + " token.");
return pos + 1;
}
private final int jjStartNfaWithStates_0(int pos, int kind, int state)
{
jjmatchedKind = kind;
jjmatchedPos = pos;
+ debugStream.println(" No more string literal token matches are possible.");
+ debugStream.println(" Currently matched the first " + (jjmatchedPos + 1) + "
characters as a " + tokenImage[jjmatchedKind] + " token.");
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) { return pos + 1; }
+ debugStream.println("<" + lexStateNames[curLexState] + ">" + "Current character
: " + TokenMgrError.addEscapes(String.valueOf(curChar)) + " (" + (int)curChar + ")");
return jjMoveNfa_0(state, pos + 1);
}
private final int jjMoveStringLiteralDfa0_0()
@@ -134,16 +140,25 @@
case 116:
return jjMoveStringLiteralDfa1_0(0x200000L);
default :
+ debugStream.println(" No string literal matches possible.");
return jjMoveNfa_0(0, 0);
}
}
private final int jjMoveStringLiteralDfa1_0(long active0)
{
+ if (jjmatchedKind != 0 && jjmatchedKind != 0x7fffffff)
+ debugStream.println(" Currently matched the first " + (jjmatchedPos + 1) +
" characters as a " + tokenImage[jjmatchedKind] + " token.");
+ debugStream.println(" Possible string literal matches : { "
+ +
+ jjKindsForBitVector(0, active0) + " } ");
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) {
jjStopStringLiteralDfa_0(0, active0);
+ if (jjmatchedKind != 0 && jjmatchedKind != 0x7fffffff)
+ debugStream.println(" Currently matched the first " + (jjmatchedPos + 1)
+ " characters as a " + tokenImage[jjmatchedKind] + " token.");
return 1;
}
+ debugStream.println("<" + lexStateNames[curLexState] + ">" + "Current character
: " + TokenMgrError.addEscapes(String.valueOf(curChar)) + " (" + (int)curChar + ")");
switch(curChar)
{
case 97:
@@ -165,6 +180,7 @@
case 121:
return jjMoveStringLiteralDfa2_0(active0, 0x100000L);
default :
+ debugStream.println(" No string literal matches possible.");
break;
}
return jjStartNfa_0(0, active0);
@@ -173,11 +189,19 @@
{
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(0, old0);
+ if (jjmatchedKind != 0 && jjmatchedKind != 0x7fffffff)
+ debugStream.println(" Currently matched the first " + (jjmatchedPos + 1) +
" characters as a " + tokenImage[jjmatchedKind] + " token.");
+ debugStream.println(" Possible string literal matches : { "
+ +
+ jjKindsForBitVector(0, active0) + " } ");
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) {
jjStopStringLiteralDfa_0(1, active0);
+ if (jjmatchedKind != 0 && jjmatchedKind != 0x7fffffff)
+ debugStream.println(" Currently matched the first " + (jjmatchedPos + 1)
+ " characters as a " + tokenImage[jjmatchedKind] + " token.");
return 2;
}
+ debugStream.println("<" + lexStateNames[curLexState] + ">" + "Current character
: " + TokenMgrError.addEscapes(String.valueOf(curChar)) + " (" + (int)curChar + ")");
switch(curChar)
{
case 97:
@@ -201,6 +225,7 @@
case 120:
return jjMoveStringLiteralDfa3_0(active0, 0x220000L);
default :
+ debugStream.println(" No string literal matches possible.");
break;
}
return jjStartNfa_0(1, active0);
@@ -209,11 +234,19 @@
{
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(1, old0);
+ if (jjmatchedKind != 0 && jjmatchedKind != 0x7fffffff)
+ debugStream.println(" Currently matched the first " + (jjmatchedPos + 1) +
" characters as a " + tokenImage[jjmatchedKind] + " token.");
+ debugStream.println(" Possible string literal matches : { "
+ +
+ jjKindsForBitVector(0, active0) + " } ");
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) {
jjStopStringLiteralDfa_0(2, active0);
+ if (jjmatchedKind != 0 && jjmatchedKind != 0x7fffffff)
+ debugStream.println(" Currently matched the first " + (jjmatchedPos + 1)
+ " characters as a " + tokenImage[jjmatchedKind] + " token.");
return 3;
}
+ debugStream.println("<" + lexStateNames[curLexState] + ">" + "Current character
: " + TokenMgrError.addEscapes(String.valueOf(curChar)) + " (" + (int)curChar + ")");
switch(curChar)
{
case 97:
@@ -249,6 +282,7 @@
return jjStartNfaWithStates_0(3, 21, 14);
return jjMoveStringLiteralDfa4_0(active0, 0x40000L);
default :
+ debugStream.println(" No string literal matches possible.");
break;
}
return jjStartNfa_0(2, active0);
@@ -257,11 +291,19 @@
{
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(2, old0);
+ if (jjmatchedKind != 0 && jjmatchedKind != 0x7fffffff)
+ debugStream.println(" Currently matched the first " + (jjmatchedPos + 1) +
" characters as a " + tokenImage[jjmatchedKind] + " token.");
+ debugStream.println(" Possible string literal matches : { "
+ +
+ jjKindsForBitVector(0, active0) + " } ");
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) {
jjStopStringLiteralDfa_0(3, active0);
+ if (jjmatchedKind != 0 && jjmatchedKind != 0x7fffffff)
+ debugStream.println(" Currently matched the first " + (jjmatchedPos + 1)
+ " characters as a " + tokenImage[jjmatchedKind] + " token.");
return 4;
}
+ debugStream.println("<" + lexStateNames[curLexState] + ">" + "Current character
: " + TokenMgrError.addEscapes(String.valueOf(curChar)) + " (" + (int)curChar + ")");
switch(curChar)
{
case 99:
@@ -279,6 +321,7 @@
return jjStartNfaWithStates_0(4, 15, 14);
return jjMoveStringLiteralDfa5_0(active0, 0x40L);
default :
+ debugStream.println(" No string literal matches possible.");
break;
}
return jjStartNfa_0(3, active0);
@@ -287,11 +330,19 @@
{
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(3, old0);
+ if (jjmatchedKind != 0 && jjmatchedKind != 0x7fffffff)
+ debugStream.println(" Currently matched the first " + (jjmatchedPos + 1) +
" characters as a " + tokenImage[jjmatchedKind] + " token.");
+ debugStream.println(" Possible string literal matches : { "
+ +
+ jjKindsForBitVector(0, active0) + " } ");
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) {
jjStopStringLiteralDfa_0(4, active0);
+ if (jjmatchedKind != 0 && jjmatchedKind != 0x7fffffff)
+ debugStream.println(" Currently matched the first " + (jjmatchedPos + 1)
+ " characters as a " + tokenImage[jjmatchedKind] + " token.");
return 5;
}
+ debugStream.println("<" + lexStateNames[curLexState] + ">" + "Current character
: " + TokenMgrError.addEscapes(String.valueOf(curChar)) + " (" + (int)curChar + ")");
switch(curChar)
{
case 100:
@@ -322,6 +373,7 @@
return jjStartNfaWithStates_0(5, 19, 14);
break;
default :
+ debugStream.println(" No string literal matches possible.");
break;
}
return jjStartNfa_0(4, active0);
@@ -330,11 +382,19 @@
{
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(4, old0);
+ if (jjmatchedKind != 0 && jjmatchedKind != 0x7fffffff)
+ debugStream.println(" Currently matched the first " + (jjmatchedPos + 1) +
" characters as a " + tokenImage[jjmatchedKind] + " token.");
+ debugStream.println(" Possible string literal matches : { "
+ +
+ jjKindsForBitVector(0, active0) + " } ");
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) {
jjStopStringLiteralDfa_0(5, active0);
+ if (jjmatchedKind != 0 && jjmatchedKind != 0x7fffffff)
+ debugStream.println(" Currently matched the first " + (jjmatchedPos + 1)
+ " characters as a " + tokenImage[jjmatchedKind] + " token.");
return 6;
}
+ debugStream.println("<" + lexStateNames[curLexState] + ">" + "Current character
: " + TokenMgrError.addEscapes(String.valueOf(curChar)) + " (" + (int)curChar + ")");
switch(curChar)
{
case 101:
@@ -348,6 +408,7 @@
return jjStartNfaWithStates_0(6, 10, 14);
break;
default :
+ debugStream.println(" No string literal matches possible.");
break;
}
return jjStartNfa_0(5, active0);
@@ -356,11 +417,19 @@
{
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(5, old0);
+ if (jjmatchedKind != 0 && jjmatchedKind != 0x7fffffff)
+ debugStream.println(" Currently matched the first " + (jjmatchedPos + 1) +
" characters as a " + tokenImage[jjmatchedKind] + " token.");
+ debugStream.println(" Possible string literal matches : { "
+ +
+ jjKindsForBitVector(0, active0) + " } ");
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) {
jjStopStringLiteralDfa_0(6, active0);
+ if (jjmatchedKind != 0 && jjmatchedKind != 0x7fffffff)
+ debugStream.println(" Currently matched the first " + (jjmatchedPos + 1)
+ " characters as a " + tokenImage[jjmatchedKind] + " token.");
return 7;
}
+ debugStream.println("<" + lexStateNames[curLexState] + ">" + "Current character
: " + TokenMgrError.addEscapes(String.valueOf(curChar)) + " (" + (int)curChar + ")");
switch(curChar)
{
case 115:
@@ -368,6 +437,7 @@
return jjStartNfaWithStates_0(7, 9, 14);
break;
default :
+ debugStream.println(" No string literal matches possible.");
break;
}
return jjStartNfa_0(6, active0);
@@ -433,6 +503,8 @@
jjnewStateCnt = 14;
int i = 1;
jjstateSet[0] = startState;
+ debugStream.println(" Starting NFA to match one of : " +
jjKindsForStateVector(curLexState, jjstateSet, 0, 1));
+ debugStream.println("<" + lexStateNames[curLexState] + ">" + "Current
character : " + TokenMgrError.addEscapes(String.valueOf(curChar)) + " (" +
(int)curChar + ")");
int j, kind = 0x7fffffff;
for (;;)
{
@@ -682,10 +754,14 @@
kind = 0x7fffffff;
}
++curPos;
+ if (jjmatchedKind != 0 && jjmatchedKind != 0x7fffffff)
+ debugStream.println(" Currently matched the first " + (jjmatchedPos + 1)
+ " characters as a " + tokenImage[jjmatchedKind] + " token.");
if ((i = jjnewStateCnt) == (startsAt = 14 - (jjnewStateCnt = startsAt)))
return curPos;
+ debugStream.println(" Possible kinds of longer matches : " +
jjKindsForStateVector(curLexState, jjstateSet, startsAt, i));
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) { return curPos; }
+ debugStream.println("<" + lexStateNames[curLexState] + ">" + "Current
character : " + TokenMgrError.addEscapes(String.valueOf(curChar)) + " (" +
(int)curChar + ")");
}
}
private final int jjMoveStringLiteralDfa0_1()
@@ -693,6 +769,7 @@
switch(curChar)
{
default :
+ debugStream.println(" No string literal matches possible.");
return 1;
}
}
@@ -830,6 +907,7 @@
}
catch(java.io.IOException e)
{
+ debugStream.println("Returning the <EOF> token.");
jjmatchedKind = 0;
matchedToken = jjFillToken();
return matchedToken;
@@ -840,28 +918,40 @@
case 0:
try { input_stream.backup(0);
while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
+ {
+ debugStream.println("<" + lexStateNames[curLexState] + ">" + "Skipping
character : " + TokenMgrError.addEscapes(String.valueOf(curChar)) + " (" +
(int)curChar + ")");
curChar = input_stream.BeginToken();
}
+ }
catch (java.io.IOException e1) { continue EOFLoop; }
jjmatchedKind = 0x7fffffff;
jjmatchedPos = 0;
+ debugStream.println("<" + lexStateNames[curLexState] + ">" + "Current
character : " + TokenMgrError.addEscapes(String.valueOf(curChar)) + " (" +
(int)curChar + ")");
curPos = jjMoveStringLiteralDfa0_0();
break;
case 1:
try { input_stream.backup(0);
while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
+ {
+ debugStream.println("<" + lexStateNames[curLexState] + ">" + "Skipping
character : " + TokenMgrError.addEscapes(String.valueOf(curChar)) + " (" +
(int)curChar + ")");
curChar = input_stream.BeginToken();
}
+ }
catch (java.io.IOException e1) { continue EOFLoop; }
jjmatchedKind = 0x7fffffff;
jjmatchedPos = 0;
+ debugStream.println("<" + lexStateNames[curLexState] + ">" + "Current
character : " + TokenMgrError.addEscapes(String.valueOf(curChar)) + " (" +
(int)curChar + ")");
curPos = jjMoveStringLiteralDfa0_1();
break;
}
if (jjmatchedKind != 0x7fffffff)
{
if (jjmatchedPos + 1 < curPos)
+ {
+ debugStream.println(" Putting back " + (curPos - jjmatchedPos - 1) + "
characters into the input stream.");
input_stream.backup(curPos - jjmatchedPos - 1);
+ }
+ debugStream.println("****** FOUND A " + tokenImage[jjmatchedKind] + " MATCH ("
+ TokenMgrError.addEscapes(new String(input_stream.GetSuffix(jjmatchedPos + 1))) + ")
******\n");
if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
{
matchedToken = jjFillToken();
@@ -898,5 +988,81 @@
throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column,
error_after, curChar, TokenMgrError.LEXICAL_ERROR);
}
}
+
+protected static final int[][][] statesForState = {
+ {
+ { 0, 5, 13, },
+ { 1 },
+ { 2 },
+ { 3 },
+ { 4 },
+ { 0, 5, 13, },
+ { 6 },
+ { 7, 8, 10, 11, },
+ { 7, 8, 10, 11, },
+ { 9 },
+ { 7, 8, 10, 11, },
+ { 7, 8, 10, 11, },
+ { 12 },
+ { 0, 5, 13, },
+ { 7, 8, 10, 11, },
+ },
+ null,
+
+};
+protected static final int[][] kindForState = {
+{ 25, 25, 25, 25, 25, 22, 22, 22, 22, 23, 23, 23, 28, 22},
+null
+
+};
+ int kindCnt = 0;
+ protected final String jjKindsForBitVector(int i, long vec)
+ {
+ String retVal = "";
+ if (i == 0)
+ kindCnt = 0;
+ for (int j = 0; j < 64; j++)
+ {
+ if ((vec & (1L << j)) != 0L)
+ {
+ if (kindCnt++ > 0)
+ retVal += ", ";
+ if (kindCnt % 5 == 0)
+ retVal += "\n ";
+ retVal += tokenImage[i * 64 + j];
+ }
+ }
+ return retVal;
+ }
+
+ protected final String jjKindsForStateVector(int lexState, int[] vec, int start,
int end)
+ {
+ boolean[] kindDone = new boolean[32];
+ String retVal = "";
+ int cnt = 0;
+ for (int i = start; i < end; i++)
+ {
+ if (vec[i] == -1)
+ continue;
+ int[] stateSet = statesForState[curLexState][vec[i]];
+ for (int j = 0; j < stateSet.length; j++)
+ {
+ int state = stateSet[j];
+ if (!kindDone[kindForState[lexState][state]])
+ {
+ kindDone[kindForState[lexState][state]] = true;
+ if (cnt++ > 0)
+ retVal += ", ";
+ if (cnt % 5 == 0)
+ retVal += "\n ";
+ retVal += tokenImage[kindForState[lexState][state]];
+ }
+ }
+ }
+ if (cnt == 0)
+ return "{ }";
+ else
+ return "{ " + retVal + " }";
+ }
}
1.1
jakarta-turbine-maven/src/java/org/apache/maven/jrcs/rcs/JavaCharStream.java
Index: JavaCharStream.java
===================================================================
/* Generated By:JavaCC: Do not edit this line. JavaCharStream.java Version 2.1 */
package org.apache.maven.jrcs.rcs;
/**
* An implementation of interface CharStream, where the stream is assumed to
* contain only ASCII characters (with java-like unicode escape processing).
*/
public final class JavaCharStream
{
public static final boolean staticFlag = false;
static final int hexval(char c) throws java.io.IOException {
switch(c)
{
case '0' :
return 0;
case '1' :
return 1;
case '2' :
return 2;
case '3' :
return 3;
case '4' :
return 4;
case '5' :
return 5;
case '6' :
return 6;
case '7' :
return 7;
case '8' :
return 8;
case '9' :
return 9;
case 'a' :
case 'A' :
return 10;
case 'b' :
case 'B' :
return 11;
case 'c' :
case 'C' :
return 12;
case 'd' :
case 'D' :
return 13;
case 'e' :
case 'E' :
return 14;
case 'f' :
case 'F' :
return 15;
}
throw new java.io.IOException(); // Should never come here
}
public int bufpos = -1;
int bufsize;
int available;
int tokenBegin;
private int bufline[];
private int bufcolumn[];
private int column = 0;
private int line = 1;
private boolean prevCharIsCR = false;
private boolean prevCharIsLF = false;
private java.io.Reader inputStream;
private char[] nextCharBuf;
private char[] buffer;
private int maxNextCharInd = 0;
private int nextCharInd = -1;
private int inBuf = 0;
private final void ExpandBuff(boolean wrapAround)
{
char[] newbuffer = new char[bufsize + 2048];
int newbufline[] = new int[bufsize + 2048];
int newbufcolumn[] = new int[bufsize + 2048];
try
{
if (wrapAround)
{
System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
System.arraycopy(buffer, 0, newbuffer,
bufsize - tokenBegin, bufpos);
buffer = newbuffer;
System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize -
tokenBegin);
System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
bufline = newbufline;
System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize -
tokenBegin);
System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin,
bufpos);
bufcolumn = newbufcolumn;
bufpos += (bufsize - tokenBegin);
}
else
{
System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
buffer = newbuffer;
System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize -
tokenBegin);
bufline = newbufline;
System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize -
tokenBegin);
bufcolumn = newbufcolumn;
bufpos -= tokenBegin;
}
}
catch (Throwable t)
{
throw new Error(t.getMessage());
}
available = (bufsize += 2048);
tokenBegin = 0;
}
private final void FillBuff() throws java.io.IOException
{
int i;
if (maxNextCharInd == 4096)
maxNextCharInd = nextCharInd = 0;
try {
if ((i = inputStream.read(nextCharBuf, maxNextCharInd,
4096 - maxNextCharInd)) == -1)
{
inputStream.close();
throw new java.io.IOException();
}
else
maxNextCharInd += i;
return;
}
catch(java.io.IOException e) {
if (bufpos != 0)
{
--bufpos;
backup(0);
}
else
{
bufline[bufpos] = line;
bufcolumn[bufpos] = column;
}
throw e;
}
}
private final char ReadByte() throws java.io.IOException
{
if (++nextCharInd >= maxNextCharInd)
FillBuff();
return nextCharBuf[nextCharInd];
}
public final char BeginToken() throws java.io.IOException
{
if (inBuf > 0)
{
--inBuf;
if (++bufpos == bufsize)
bufpos = 0;
tokenBegin = bufpos;
return buffer[bufpos];
}
tokenBegin = 0;
bufpos = -1;
return readChar();
}
private final void AdjustBuffSize()
{
if (available == bufsize)
{
if (tokenBegin > 2048)
{
bufpos = 0;
available = tokenBegin;
}
else
ExpandBuff(false);
}
else if (available > tokenBegin)
available = bufsize;
else if ((tokenBegin - available) < 2048)
ExpandBuff(true);
else
available = tokenBegin;
}
private final void UpdateLineColumn(char c)
{
column++;
if (prevCharIsLF)
{
prevCharIsLF = false;
line += (column = 1);
}
else if (prevCharIsCR)
{
prevCharIsCR = false;
if (c == '\n')
{
prevCharIsLF = true;
}
else
line += (column = 1);
}
switch (c)
{
case '\r' :
prevCharIsCR = true;
break;
case '\n' :
prevCharIsLF = true;
break;
case '\t' :
column--;
column += (8 - (column & 07));
break;
default :
break;
}
bufline[bufpos] = line;
bufcolumn[bufpos] = column;
}
public final char readChar() throws java.io.IOException
{
if (inBuf > 0)
{
--inBuf;
if (++bufpos == bufsize)
bufpos = 0;
return buffer[bufpos];
}
char c;
if (++bufpos == available)
AdjustBuffSize();
if ((buffer[bufpos] = c = ReadByte()) == '\\')
{
UpdateLineColumn(c);
int backSlashCnt = 1;
for (;;) // Read all the backslashes
{
if (++bufpos == available)
AdjustBuffSize();
try
{
if ((buffer[bufpos] = c = ReadByte()) != '\\')
{
UpdateLineColumn(c);
// found a non-backslash char.
if ((c == 'u') && ((backSlashCnt & 1) == 1))
{
if (--bufpos < 0)
bufpos = bufsize - 1;
break;
}
backup(backSlashCnt);
return '\\';
}
}
catch(java.io.IOException e)
{
if (backSlashCnt > 1)
backup(backSlashCnt);
return '\\';
}
UpdateLineColumn(c);
backSlashCnt++;
}
// Here, we have seen an odd number of backslash's followed by a 'u'
try
{
while ((c = ReadByte()) == 'u')
++column;
buffer[bufpos] = c = (char)(hexval(c) << 12 |
hexval(ReadByte()) << 8 |
hexval(ReadByte()) << 4 |
hexval(ReadByte()));
column += 4;
}
catch(java.io.IOException e)
{
throw new Error("Invalid escape character at line " + line +
" column " + column + ".");
}
if (backSlashCnt == 1)
return c;
else
{
backup(backSlashCnt - 1);
return '\\';
}
}
else
{
UpdateLineColumn(c);
return (c);
}
}
/**
* @deprecated
* @see #getEndColumn
*/
public final int getColumn() {
return bufcolumn[bufpos];
}
/**
* @deprecated
* @see #getEndLine
*/
public final int getLine() {
return bufline[bufpos];
}
public final int getEndColumn() {
return bufcolumn[bufpos];
}
public final int getEndLine() {
return bufline[bufpos];
}
public final int getBeginColumn() {
return bufcolumn[tokenBegin];
}
public final int getBeginLine() {
return bufline[tokenBegin];
}
public final void backup(int amount) {
inBuf += amount;
if ((bufpos -= amount) < 0)
bufpos += bufsize;
}
public JavaCharStream(java.io.Reader dstream,
int startline, int startcolumn, int buffersize)
{
inputStream = dstream;
line = startline;
column = startcolumn - 1;
available = bufsize = buffersize;
buffer = new char[buffersize];
bufline = new int[buffersize];
bufcolumn = new int[buffersize];
nextCharBuf = new char[4096];
}
public JavaCharStream(java.io.Reader dstream,
int startline, int startcolumn)
{
this(dstream, startline, startcolumn, 4096);
}
public JavaCharStream(java.io.Reader dstream)
{
this(dstream, 1, 1, 4096);
}
public void ReInit(java.io.Reader dstream,
int startline, int startcolumn, int buffersize)
{
inputStream = dstream;
line = startline;
column = startcolumn - 1;
if (buffer == null || buffersize != buffer.length)
{
available = bufsize = buffersize;
buffer = new char[buffersize];
bufline = new int[buffersize];
bufcolumn = new int[buffersize];
nextCharBuf = new char[4096];
}
prevCharIsLF = prevCharIsCR = false;
tokenBegin = inBuf = maxNextCharInd = 0;
nextCharInd = bufpos = -1;
}
public void ReInit(java.io.Reader dstream,
int startline, int startcolumn)
{
ReInit(dstream, startline, startcolumn, 4096);
}
public void ReInit(java.io.Reader dstream)
{
ReInit(dstream, 1, 1, 4096);
}
public JavaCharStream(java.io.InputStream dstream, int startline,
int startcolumn, int buffersize)
{
this(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
}
public JavaCharStream(java.io.InputStream dstream, int startline,
int startcolumn)
{
this(dstream, startline, startcolumn, 4096);
}
public JavaCharStream(java.io.InputStream dstream)
{
this(dstream, 1, 1, 4096);
}
public void ReInit(java.io.InputStream dstream, int startline,
int startcolumn, int buffersize)
{
ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
}
public void ReInit(java.io.InputStream dstream, int startline,
int startcolumn)
{
ReInit(dstream, startline, startcolumn, 4096);
}
public void ReInit(java.io.InputStream dstream)
{
ReInit(dstream, 1, 1, 4096);
}
public final String GetImage()
{
if (bufpos >= tokenBegin)
return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
else
return new String(buffer, tokenBegin, bufsize - tokenBegin) +
new String(buffer, 0, bufpos + 1);
}
public final char[] GetSuffix(int len)
{
char[] ret = new char[len];
if ((bufpos + 1) >= len)
System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
else
{
System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
len - bufpos - 1);
System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
}
return ret;
}
public void Done()
{
nextCharBuf = null;
buffer = null;
bufline = null;
bufcolumn = null;
}
/**
* Method to adjust line and column numbers for the start of a token.<BR>
*/
public void adjustBeginLineColumn(int newLine, int newCol)
{
int start = tokenBegin;
int len;
if (bufpos >= tokenBegin)
{
len = bufpos - tokenBegin + inBuf + 1;
}
else
{
len = bufsize - tokenBegin + bufpos + 1 + inBuf;
}
int i = 0, j = 0, k = 0;
int nextColDiff = 0, columnDiff = 0;
while (i < len &&
bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
{
bufline[j] = newLine;
nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
bufcolumn[j] = newCol + columnDiff;
columnDiff = nextColDiff;
i++;
}
if (i < len)
{
bufline[j] = newLine++;
bufcolumn[j] = newCol + columnDiff;
while (i++ < len)
{
if (bufline[j = start % bufsize] != bufline[++start % bufsize])
bufline[j] = newLine++;
else
bufline[j] = newLine;
}
}
line = bufline[j];
column = bufcolumn[j];
}
}
--
To unsubscribe, e-mail: <mailto:[EMAIL PROTECTED]>
For additional commands, e-mail: <mailto:[EMAIL PROTECTED]>
