[Git][java-team/jep][master] 8 commits: Leaving only the location of GPL-2 license on Debian OS. Collecting copyright...
Andrius Merkys
gitlab at salsa.debian.org
Mon Nov 18 11:22:08 GMT 2019
Andrius Merkys pushed to branch master at Debian Java Maintainers / jep
Commits:
725961d2 by Andrius Merkys at 2019-11-18T06:40:55Z
Leaving only the location of GPL-2 license on Debian OS. Collecting copyright years from files headers.
- - - - -
75c57ead by Andrius Merkys at 2019-11-18T06:45:32Z
Dropping -doc package.
- - - - -
cfb1d476 by Andrius Merkys at 2019-11-18T06:53:03Z
Adding a patch to remove prebuilt files (instead of doing so in debian/rules).
- - - - -
ec35b8a0 by Andrius Merkys at 2019-11-18T06:54:53Z
Adding description for remove-prebuilt-files.patch.
- - - - -
9a0225f2 by Andrius Merkys at 2019-11-18T06:55:49Z
Preparing for release.
- - - - -
a0a07f52 by Andrius Merkys at 2019-11-18T07:10:30Z
Bringing back JAR building.
- - - - -
d89db4d4 by Andrius Merkys at 2019-11-18T07:11:01Z
Updating debian/changelog.
- - - - -
c47d356f by Andrius Merkys at 2019-11-18T10:59:53Z
Removing src/org/nfunk/jep/Parser.jj.
- - - - -
7 changed files:
- debian/changelog
- debian/control
- debian/copyright
- − debian/libjep-java-doc.javadoc
- + debian/patches/remove-prebuilt-files.patch
- debian/patches/series
- debian/rules
Changes:
=====================================
debian/changelog
=====================================
@@ -1,3 +1,13 @@
+jep (2.4.1+ds-2) unstable; urgency=medium
+
+ * Leaving only the location of GPL-2 license on Debian OS. Collecting
+ copyright years from files headers.
+ * Dropping -doc package.
+ * Adding a patch to remove prebuilt files instead of doing so in
+ debian/rules.
+
+ -- Andrius Merkys <merkys at debian.org> Mon, 18 Nov 2019 02:10:39 -0500
+
jep (2.4.1+ds-1) unstable; urgency=low
* Initial release. (Closes: #934544)
=====================================
debian/control
=====================================
@@ -30,22 +30,3 @@ Description: Java Expression Parser
instantly evaluate it. Jep supports user defined variables, constants, and
functions. A number of common mathematical functions and constants are
included.
-
-Package: libjep-java-doc
-Architecture: all
-Section: doc
-Depends:
- libjs-jquery,
- libjs-jquery-ui,
- ${java:Depends},
- ${misc:Depends},
-Recommends:
- ${java:Recommends},
-Description: Java Expression Parser - documentation
- Jep Java parses and evaluates mathematical expressions with only a few lines
- of code. This package allows your users to enter a formula as a string, and
- instantly evaluate it. Jep supports user defined variables, constants, and
- functions. A number of common mathematical functions and constants are
- included.
- .
- This package contains the Javadoc API
=====================================
debian/copyright
=====================================
@@ -9,27 +9,13 @@ Files-Excluded:
Comment: Precompiled files are removed.
Files: *
-Copyright: 2019 Nathan Funk and Richard Morris
+Copyright: 2002-2007, Nathan Funk and Richard Morris
License: GPL-2
Files: debian/*
-Copyright: 2019 Andrius Merkys <merkys at debian.org>
+Copyright: 2019, Andrius Merkys <merkys at debian.org>
License: GPL-2
License: GPL-2
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- .
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
- .
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
- .
On Debian systems, the complete text of the GNU General
Public License can be found in `/usr/share/common-licenses/GPL-2'.
=====================================
debian/libjep-java-doc.javadoc deleted
=====================================
@@ -1 +0,0 @@
-doc/javadoc
=====================================
debian/patches/remove-prebuilt-files.patch
=====================================
@@ -0,0 +1,2637 @@
+Description: Removing prebuilt Java sources.
+Author: Andrius Merkys <merkys at debian.org>
+--- a/src/org/nfunk/jep/JavaCharStream.java
++++ /dev/null
+@@ -1,547 +0,0 @@
+-/* Generated By:JavaCC: Do not edit this line. JavaCharStream.java Version 3.0 */
+-package org.nfunk.jep;
+-
+-/**
+- * An implementation of interface CharStream, where the stream is assumed to
+- * contain only ASCII characters (with java-like unicode escape processing).
+- */
+-
+-public 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;
+- protected int bufline[];
+- protected int bufcolumn[];
+-
+- protected int column = 0;
+- protected int line = 1;
+-
+- protected boolean prevCharIsCR = false;
+- protected boolean prevCharIsLF = false;
+-
+- protected java.io.Reader inputStream;
+-
+- protected char[] nextCharBuf;
+- protected char[] buffer;
+- protected int maxNextCharInd = 0;
+- protected int nextCharInd = -1;
+- protected int inBuf = 0;
+-
+- protected 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;
+- }
+-
+- protected 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;
+- }
+- }
+-
+- protected char ReadByte() throws java.io.IOException
+- {
+- if (++nextCharInd >= maxNextCharInd)
+- FillBuff();
+-
+- return nextCharBuf[nextCharInd];
+- }
+-
+- public 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();
+- }
+-
+- protected 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;
+- }
+-
+- protected 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 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 int getColumn() {
+- return bufcolumn[bufpos];
+- }
+-
+- /**
+- * @deprecated
+- * @see #getEndLine
+- */
+-
+- public int getLine() {
+- return bufline[bufpos];
+- }
+-
+- public int getEndColumn() {
+- return bufcolumn[bufpos];
+- }
+-
+- public int getEndLine() {
+- return bufline[bufpos];
+- }
+-
+- public int getBeginColumn() {
+- return bufcolumn[tokenBegin];
+- }
+-
+- public int getBeginLine() {
+- return bufline[tokenBegin];
+- }
+-
+- public 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 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 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.
+- */
+- 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];
+- }
+-
+-}
+--- a/src/org/nfunk/jep/ParseException.java
++++ /dev/null
+@@ -1,239 +0,0 @@
+-/* Generated By:JavaCC: Do not edit this line. ParseException.java Version 3.0 */
+-package org.nfunk.jep;
+-
+-/**
+- * This exception is thrown when parse errors are encountered.
+- * You can explicitly create objects of this exception type by
+- * calling the method generateParseException in the generated
+- * parser.
+- *
+- * You can modify this class to customize your error reporting
+- * mechanisms so long as you retain the public fields.
+- */
+-public class ParseException extends Exception {
+- private static final long serialVersionUID = 8169613785780477459L;
+-
+-/**
+- * This constructor is used by the method "generateParseException"
+- * in the generated parser. Calling this constructor generates
+- * a new object of this type with the fields "currentToken",
+- * "expectedTokenSequences", and "tokenImage" set. The boolean
+- * flag "specialConstructor" is also set to true to indicate that
+- * this constructor was used to create this object.
+- * This constructor calls its super class with the empty string
+- * to force the "toString" method of parent class "Throwable" to
+- * print the error message in the form:
+- * ParseException: <result of getMessage>
+- */
+- public ParseException(Token currentTokenVal,
+- int[][] expectedTokenSequencesVal,
+- String[] tokenImageVal
+- )
+- {
+- super("");
+- specialConstructor = true;
+- currentToken = currentTokenVal;
+- expectedTokenSequences = expectedTokenSequencesVal;
+- tokenImage = tokenImageVal;
+- }
+-
+- /**
+- * The following constructors are for use by you for whatever
+- * purpose you can think of. Constructing the exception in this
+- * manner makes the exception behave in the normal way - i.e., as
+- * documented in the class "Throwable". The fields "errorToken",
+- * "expectedTokenSequences", and "tokenImage" do not contain
+- * relevant information. The JavaCC generated code does not use
+- * these constructors.
+- */
+-
+- public ParseException() {
+- super();
+- specialConstructor = false;
+- }
+-
+- public ParseException(String message) {
+- super(message);
+- specialConstructor = false;
+- }
+-
+- /**
+- * This variable determines which constructor was used to create
+- * this object and thereby affects the semantics of the
+- * "getMessage" method (see below).
+- */
+- protected boolean specialConstructor;
+-
+- /**
+- * This is the last token that has been consumed successfully. If
+- * this object has been created due to a parse error, the token
+- * following this token will (therefore) be the first error token.
+- */
+- public Token currentToken;
+-
+- /**
+- * Each entry in this array is an array of integers. Each array
+- * of integers represents a sequence of tokens (by their ordinal
+- * values) that is expected at this point of the parse.
+- */
+- public int[][] expectedTokenSequences;
+-
+- /**
+- * This is a reference to the "tokenImage" array of the generated
+- * parser within which the parse error occurred. This array is
+- * defined in the generated ...Constants interface.
+- */
+- public String[] tokenImage;
+-
+- /**
+- * This method has the standard behavior when this object has been
+- * created using the standard constructors. Otherwise, it uses
+- * "currentToken" and "expectedTokenSequences" to generate a parse
+- * error message and returns it. If this object has been created
+- * due to a parse error, and you do not catch it (it gets thrown
+- * from the parser), then this method is called during the printing
+- * of the final stack trace, and hence the correct error message
+- * gets displayed.
+- */
+- public String getMessage() {
+- if (!specialConstructor) {
+- return super.getMessage();
+- }
+- String expected = "";
+- int maxSize = 0;
+- for (int i = 0; i < expectedTokenSequences.length; i++) {
+- if (maxSize < expectedTokenSequences[i].length) {
+- maxSize = expectedTokenSequences[i].length;
+- }
+- for (int j = 0; j < expectedTokenSequences[i].length; j++) {
+- expected += tokenImage[expectedTokenSequences[i][j]] + " ";
+- }
+- if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) {
+- expected += "...";
+- }
+- expected += eol + " ";
+- }
+- String retval = "Encountered \"";
+- Token tok = currentToken.next;
+- for (int i = 0; i < maxSize; i++) {
+- if (i != 0) retval += " ";
+- if (tok.kind == 0) {
+- retval += tokenImage[0];
+- break;
+- }
+- retval += add_escapes(tok.image);
+- tok = tok.next;
+- }
+- retval += "\" at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn;
+- retval += "." + eol;
+- if (expectedTokenSequences.length == 1) {
+- retval += "Was expecting:" + eol + " ";
+- } else {
+- retval += "Was expecting one of:" + eol + " ";
+- }
+- retval += expected;
+- return retval;
+- }
+-
+- /**
+- * getErrorInfo() was added to the parser generated code to provide clean
+- * output instead of the standard format of Exception.toString(). It returns
+- * a short description of the error that occurred as well as the position of
+- * next token as part of the string.
+- */
+- public String getErrorInfo()
+- {
+- if (!specialConstructor) {
+- try {
+- return super.getMessage() + " at column " + currentToken.next.beginColumn + ".";
+- }
+- catch (Exception e) {
+- return super.getMessage();
+- }
+- }
+- String expected = "";
+- int maxSize = 0;
+- for (int i = 0; i < expectedTokenSequences.length; i++) {
+- if (maxSize < expectedTokenSequences[i].length) {
+- maxSize = expectedTokenSequences[i].length;
+- }
+- for (int j = 0; j < expectedTokenSequences[i].length; j++) {
+- expected += tokenImage[expectedTokenSequences[i][j]] + " ";
+- }
+- if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) {
+- expected += "...";
+- }
+- expected += eol + " ";
+- }
+-
+- String retval = "Unexpected \"";
+- Token tok = currentToken.next;
+- for (int i = 0; i < maxSize; i++) {
+- if (i != 0) retval += " ";
+- if (tok.kind == 0) {
+- retval += tokenImage[0];
+- break;
+- }
+- retval += add_escapes(tok.image);
+- tok = tok.next;
+- }
+- retval += "\" at column " + currentToken.next.beginColumn + ".";
+- return retval;
+- }
+-
+- /**
+- * The end of line string for this machine.
+- */
+- protected String eol = System.getProperty("line.separator", "\n");
+-
+- /**
+- * Used to convert raw characters to their escaped version
+- * when these raw version cannot be used as part of an ASCII
+- * string literal.
+- */
+- protected String add_escapes(String str) {
+- StringBuffer retval = new StringBuffer();
+- char ch;
+- for (int i = 0; i < str.length(); i++) {
+- switch (str.charAt(i))
+- {
+- case 0 :
+- continue;
+- case '\b':
+- retval.append("\\b");
+- continue;
+- case '\t':
+- retval.append("\\t");
+- continue;
+- case '\n':
+- retval.append("\\n");
+- continue;
+- case '\f':
+- retval.append("\\f");
+- continue;
+- case '\r':
+- retval.append("\\r");
+- continue;
+- case '\"':
+- retval.append("\\\"");
+- continue;
+- case '\'':
+- retval.append("\\\'");
+- continue;
+- case '\\':
+- retval.append("\\\\");
+- continue;
+- default:
+- if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
+- String s = "0000" + Integer.toString(ch, 16);
+- retval.append("\\u" + s.substring(s.length() - 4, s.length()));
+- } else {
+- retval.append(ch);
+- }
+- continue;
+- }
+- }
+- return retval.toString();
+- }
+-
+-}
+--- a/src/org/nfunk/jep/Token.java
++++ /dev/null
+@@ -1,81 +0,0 @@
+-/* Generated By:JavaCC: Do not edit this line. Token.java Version 3.0 */
+-package org.nfunk.jep;
+-
+-/**
+- * Describes the input token stream.
+- */
+-
+-public class Token {
+-
+- /**
+- * An integer that describes the kind of this token. This numbering
+- * system is determined by JavaCCParser, and a table of these numbers is
+- * stored in the file ...Constants.java.
+- */
+- public int kind;
+-
+- /**
+- * beginLine and beginColumn describe the position of the first character
+- * of this token; endLine and endColumn describe the position of the
+- * last character of this token.
+- */
+- public int beginLine, beginColumn, endLine, endColumn;
+-
+- /**
+- * The string image of the token.
+- */
+- public String image;
+-
+- /**
+- * A reference to the next regular (non-special) token from the input
+- * stream. If this is the last token from the input stream, or if the
+- * token manager has not read tokens beyond this one, this field is
+- * set to null. This is true only if this token is also a regular
+- * token. Otherwise, see below for a description of the contents of
+- * this field.
+- */
+- public Token next;
+-
+- /**
+- * This field is used to access special tokens that occur prior to this
+- * token, but after the immediately preceding regular (non-special) token.
+- * If there are no such special tokens, this field is set to null.
+- * When there are more than one such special token, this field refers
+- * to the last of these special tokens, which in turn refers to the next
+- * previous special token through its specialToken field, and so on
+- * until the first special token (whose specialToken field is null).
+- * The next fields of special tokens refer to other special tokens that
+- * immediately follow it (without an intervening regular token). If there
+- * is no such token, this field is null.
+- */
+- public Token specialToken;
+-
+- /**
+- * Returns the image.
+- */
+- public String toString()
+- {
+- return image;
+- }
+-
+- /**
+- * Returns a new Token object, by default. However, if you want, you
+- * can create and return subclass objects based on the value of ofKind.
+- * Simply add the cases to the switch for all those special cases.
+- * For example, if you have a subclass of Token called IDToken that
+- * you want to create if ofKind is ID, simlpy add something like :
+- *
+- * case MyParserConstants.ID : return new IDToken();
+- *
+- * to the following switch statement. Then you can cast matchedToken
+- * variable to the appropriate type and use it in your lexical actions.
+- */
+- public static final Token newToken(int ofKind)
+- {
+- switch(ofKind)
+- {
+- default : return new Token();
+- }
+- }
+-
+-}
+--- a/src/org/nfunk/jep/TokenMgrError.java
++++ /dev/null
+@@ -1,133 +0,0 @@
+-/* Generated By:JavaCC: Do not edit this line. TokenMgrError.java Version 3.0 */
+-package org.nfunk.jep;
+-
+-public class TokenMgrError extends Error
+-{
+- /*
+- * Ordinals for various reasons why an Error of this type can be thrown.
+- */
+-
+- /**
+- * Lexical error occured.
+- */
+- static final int LEXICAL_ERROR = 0;
+-
+- /**
+- * An attempt wass made to create a second instance of a static token manager.
+- */
+- static final int STATIC_LEXER_ERROR = 1;
+-
+- /**
+- * Tried to change to an invalid lexical state.
+- */
+- static final int INVALID_LEXICAL_STATE = 2;
+-
+- /**
+- * Detected (and bailed out of) an infinite loop in the token manager.
+- */
+- static final int LOOP_DETECTED = 3;
+-
+- /**
+- * Indicates the reason why the exception is thrown. It will have
+- * one of the above 4 values.
+- */
+- int errorCode;
+-
+- /**
+- * Replaces unprintable characters by their espaced (or unicode escaped)
+- * equivalents in the given string
+- */
+- protected static final String addEscapes(String str) {
+- StringBuffer retval = new StringBuffer();
+- char ch;
+- for (int i = 0; i < str.length(); i++) {
+- switch (str.charAt(i))
+- {
+- case 0 :
+- continue;
+- case '\b':
+- retval.append("\\b");
+- continue;
+- case '\t':
+- retval.append("\\t");
+- continue;
+- case '\n':
+- retval.append("\\n");
+- continue;
+- case '\f':
+- retval.append("\\f");
+- continue;
+- case '\r':
+- retval.append("\\r");
+- continue;
+- case '\"':
+- retval.append("\\\"");
+- continue;
+- case '\'':
+- retval.append("\\\'");
+- continue;
+- case '\\':
+- retval.append("\\\\");
+- continue;
+- default:
+- if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
+- String s = "0000" + Integer.toString(ch, 16);
+- retval.append("\\u" + s.substring(s.length() - 4, s.length()));
+- } else {
+- retval.append(ch);
+- }
+- continue;
+- }
+- }
+- return retval.toString();
+- }
+-
+- /**
+- * Returns a detailed message for the Error when it is thrown by the
+- * token manager to indicate a lexical error.
+- * Parameters :
+- * EOFSeen : indicates if EOF caused the lexicl error
+- * curLexState : lexical state in which this error occured
+- * errorLine : line number when the error occured
+- * errorColumn : column number when the error occured
+- * errorAfter : prefix that was seen before this error occured
+- * curchar : the offending character
+- * Note: You can customize the lexical error message by modifying this method.
+- */
+- protected static String LexicalError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar) {
+- return("Lexical error at line " +
+- errorLine + ", column " +
+- errorColumn + ". Encountered: " +
+- (EOFSeen ? "<EOF> " : ("\"" + addEscapes(String.valueOf(curChar)) + "\"") + " (" + (int)curChar + "), ") +
+- "after : \"" + addEscapes(errorAfter) + "\"");
+- }
+-
+- /**
+- * You can also modify the body of this method to customize your error messages.
+- * For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not
+- * of end-users concern, so you can return something like :
+- *
+- * "Internal Error : Please file a bug report .... "
+- *
+- * from this method for such cases in the release version of your parser.
+- */
+- public String getMessage() {
+- return super.getMessage();
+- }
+-
+- /*
+- * Constructors of various flavors follow.
+- */
+-
+- public TokenMgrError() {
+- }
+-
+- public TokenMgrError(String message, int reason) {
+- super(message);
+- errorCode = reason;
+- }
+-
+- public TokenMgrError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar, int reason) {
+- this(LexicalError(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason);
+- }
+-}
+--- a/src/org/nfunk/jep/Parser.jj
++++ /dev/null
+@@ -1,1620 +0,0 @@
+-/*@bgen(jjtree) Generated By:JJTree: Do not edit this line. /Users/singularsys/Documents/workspace/jep-2.4/src/org/nfunk/jep/Parser.jj */
+-/*@egen*//***************************************************************
+-
+- JEP 2.4.1, Extensions 1.1.1
+- April 30 2007
+- (c) Copyright 2007, Nathan Funk and Richard Morris
+- See LICENSE-*.txt for license information.
+-
+-This file contains the grammar from which the parser is
+-generated. The parser generation tools being used are JavaCC
+-and its component JJTree. JJTree processes the .jjt file and
+-generates the .jj file. This file is then used be JavaCC to
+-generate the final java classes.
+-
+-Knowledge of parser generation is definitely beneficial if you
+-are planning to make changes to this file. Although many parts
+-are self explanatory, it is helpful to know how the grammar is
+-handled by JJTree and JavaCC.
+-
+-You can follow the structure of the grammar by starting in the
+-line which reads "ASTStart Start() #Start : {}". From there you
+-will be able to trace the same path the parser follows when
+-parsing an expression.
+-
+-The concept of precedence is very important. Since this is a
+-recursive descent parser, it is easy to see which operators have
+-higher order of precedence. The following table outlines the
+-order incorporated in this grammar.
+-
+-Order of precedence (from lowest to highest):
+-
+- || or (logical)
+- && and (logical)
+- == != equal, not equal
+- < > <= >= less, greater, less or equal, greater or equal
+- + - addition, subtraction
+- * / % multiplication, division, modulus
+- ! + - not, unary +/-
+- ^ power
+-
+-The order of precedence is greatly inspired by the operator
+-precedence of the C language. See "The C Programming Language"
+-Kernighan & Richie 2nd Ed p.53. Java also uses a very similar
+-precedence. Note that the '^' operator is used for bitwise
+-exclusive OR in Java and C, but represents the power operator
+-in this grammar.
+-
+-***************************************************************/
+-
+-
+-
+-/***************************************************************
+-OPTIONS
+-***************************************************************/
+-options {
+- JAVA_UNICODE_ESCAPE = true;
+-// NODE_PACKAGE = "org.nfunk.jep.parser";
+-// BUILD_NODE_FILES=false;
+- STATIC = false;
+-// DEBUG_TOKEN_MANAGER = true;
+-// DEBUG_PARSER = true;
+-// DEBUG_LOOKAHEAD = true;
+-}
+-
+-
+-/***************************************************************
+-PARSER BEGIN
+-***************************************************************/
+-
+-PARSER_BEGIN(Parser)
+-package org.nfunk.jep;
+-
+-import java.util.Vector;
+-import org.nfunk.jep.function.*;
+-import org.nfunk.jep.type.*;
+-
+-public class Parser/*@bgen(jjtree)*/implements ParserTreeConstants/*@egen*/ {/*@bgen(jjtree)*/
+- protected JJTParserState jjtree = new JJTParserState();
+-
+-/*@egen*/
+- private JEP jep;
+- private SymbolTable symTab;
+- private OperatorSet opSet;
+- private int initialTokenManagerState = DEFAULT;
+-
+- public Node parseStream(java.io.Reader stream, JEP jep_in)
+- throws ParseException {
+- restart(stream,jep_in);
+- // Parse the expression, and return the
+- enable_tracing();
+- Node node = Start();
+- if (node == null) throw new ParseException("No expression entered");
+- return node.jjtGetChild(0);
+- }
+-
+- /**
+- * Restart the parse with the given stream.
+- * @since 2.3.0 beta 1
+- */
+- public void restart(java.io.Reader stream, JEP jep_in)
+- {
+- ReInit(stream);
+- this.token_source.SwitchTo(initialTokenManagerState);
+- jep = jep_in;
+- symTab = jep.getSymbolTable();
+- opSet = jep.getOperatorSet();
+- }
+- /**
+- * Continue parsing without re-initilising stream.
+- * Allows renetrancy of parser so that strings like
+- * "x=1; y=2; z=3;" can be parsed.
+- * When a semi colon is encountered parsing finishes leaving the rest of the string unparsed.
+- * Parsing can be resumed from the current position by using this method.
+- * For example
+- * <pre>
+- * XJep j = new XJep();
+- * Parser parse = j.getParse();
+- * StringReader sr = new StringReader("x=1; y=2; z=3;");
+- * parse.restart(sr,j);
+- * Node node;
+- * try {
+- * while((node = j.continueParse())!=null) {
+- * j.println(node);
+- * } }catch(ParseException e) {}
+- * </pre>
+- */
+- public Node continueParse() throws ParseException
+- {
+- ASTStart node = Start();
+- if (node==null) return null;
+- return node.jjtGetChild(0);
+- }
+-
+- private void addToErrorList(String errorStr) {
+- jep.errorList.addElement(errorStr);
+- }
+-
+- /**
+- * Sets the initial state that the token manager is in.
+- * Can be used to change how x.x is interpreted, either as a single
+- * identifier (DEFAULT) or as x <DOT> x (NO_DOT_IN_IDENTIFIERS)
+- * @param state the state to be in. Currently the only legal values are DEFAULT and NO_DOT_IN_IDENTIFIER
+- */
+- public void setInitialTokenManagerState(int state)
+- {
+- initialTokenManagerState = state;
+- }
+- /**
+- * Translate all escape sequences to characters. Inspired by Rob Millar's
+- * unescape() method in rcm.util.Str fron the Web Sphinx project.
+- *
+- * @param inputStr String containing escape characters.
+- * @return String with all escape sequences replaced.
+- */
+- private String replaceEscape(String inputStr) {
+- int len = inputStr.length();
+- int p = 0;
+- int i;
+- String metachars = "tnrbf\\\"'";
+- String chars = "\t\n\r\b\f\\\"'";
+-
+- StringBuffer output = new StringBuffer();
+-
+- while ((i = inputStr.indexOf('\\', p)) != -1) {
+- output.append(inputStr.substring(p, i));
+-
+- if (i+1 == len) break;
+-
+- // find metacharacter
+- char metac = inputStr.charAt(i+1);
+-
+- // find the index of the metac
+- int k = metachars.indexOf(metac);
+- if (k == -1) {
+- // didn't find the metachar, leave sequence as found.
+- // This code should be unreachable if the parser
+- // is functioning properly because strings containing
+- // unknown escape characters should not be accepted.
+- output.append('\\');
+- output.append(metac);
+- } else {
+- // its corresponding true char
+- output.append(chars.charAt(k));
+- }
+-
+- // skip over both escape character & metacharacter
+- p = i + 2;
+- }
+-
+- // add the end of the input string to the output
+- if (p < len)
+- output.append(inputStr.substring(p));
+-
+- return output.toString();
+- }
+-}
+-
+-PARSER_END(Parser)
+-
+-/***************************************************************
+-SKIP
+-***************************************************************/
+-
+-<*> SKIP :
+-{
+- " "
+- | "\t"
+- | "\n"
+- | "\r"
+-
+- | <"//" (~["\n","\r"])* ("\n"|"\r"|"\r\n")>
+- | <"/*" (~["*"])* "*" (~["/"] (~["*"])* "*")* "/">
+-}
+-
+-
+-/***************************************************************
+-TOKENS
+-***************************************************************/
+-
+-<*> TOKEN : /* LITERALS */
+-{
+- < INTEGER_LITERAL:
+- <DECIMAL_LITERAL>
+- >
+-|
+- < #DECIMAL_LITERAL: ["0"-"9"] (["0"-"9"])* >
+-|
+- < FLOATING_POINT_LITERAL:
+- (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)?
+- | "." (["0"-"9"])+ (<EXPONENT>)?
+- | (["0"-"9"])+ <EXPONENT>
+- >
+-|
+- < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
+-|
+- < STRING_LITERAL:
+- "\""
+- ( (~["\"","\\","\n","\r"])
+- | ("\\" ["n","t","b","r","f","\\","'","\""] )
+- )*
+- "\""
+- >
+-}
+-
+-/* IDENTIFIERS
+-
+- Letters before version 2.22
+- < #LETTER: ["_","a"-"z","A"-"Z"] >
+-
+- In Ver 2.3.0.1 presence of . in an identifier is switchable.
+- In the DEFAULT lexical state identifiers can contain a .
+- In the NO_DOT_IN_IDENTIFIERS state identifiers cannot contain a .
+- the state can be set by using
+- Parser.setInitialTokenManagerState
+-*/
+-
+-<DEFAULT> TOKEN:
+-{
+- <INDENTIFIER1: <LETTER1>(<LETTER1>|<DIGIT1>|".")*>
+- |
+- < #LETTER1:
+- [
+- "$", // $
+- "A"-"Z", // A - Z
+- "_", // _
+- "a"-"z", // a - z
+- "\u00c0"-"\u00d6", // Upper case symbols of Latin-1 Supplement
+- "\u00d8"-"\u00f6", // Lower case symbols of Latin-1 Supplement
+- "\u00f8"-"\u00ff", // More lower case symbols of Latin-1 Supplement
+- "\u0100"-"\u1fff", // Many languages (including Greek)
+- "\u3040"-"\u318f", // Hiragana, Katakana, Bopomofo, Hangul Compatibility Jamo
+- "\u3300"-"\u337f", // CJK Compatibility
+- "\u3400"-"\u3d2d", // CJK Unified Ideographs Extension A
+- "\u4e00"-"\u9fff", // CJK Unified Ideographs
+- "\uf900"-"\ufaff" // CJK Compatibility Ideographs
+- ]
+- >
+-|
+- < #DIGIT1: ["0"-"9"] >
+-}
+-
+-<NO_DOT_IN_IDENTIFIERS> TOKEN:
+-{
+- <INDENTIFIER2: <LETTER2>(<LETTER2>|<DIGIT2>)*>
+- |
+- < #LETTER2:
+- [
+- "$", // $
+- "A"-"Z", // A - Z
+- "_", // _
+- "a"-"z", // a - z
+- "\u00c0"-"\u00d6", // Upper case symbols of Latin-1 Supplement
+- "\u00d8"-"\u00f6", // Lower case symbols of Latin-1 Supplement
+- "\u00f8"-"\u00ff", // More lower case symbols of Latin-1 Supplement
+- "\u0100"-"\u1fff", // Many languages (including Greek)
+- "\u3040"-"\u318f", // Hiragana, Katakana, Bopomofo, Hangul Compatibility Jamo
+- "\u3300"-"\u337f", // CJK Compatibility
+- "\u3400"-"\u3d2d", // CJK Unified Ideographs Extension A
+- "\u4e00"-"\u9fff", // CJK Unified Ideographs
+- "\uf900"-"\ufaff" // CJK Compatibility Ideographs
+- ]
+- >
+- |
+- < #DIGIT2: ["0"-"9"] >
+-}
+-
+-/* OPERATORS */
+-<*> TOKEN:
+-{
+- < ASSIGN:"=" > // rjm
+-| < SEMI: ";" > // rjm
+-| < COMMA: "," > // rjm
+-| < GT: ">" >
+-| < LT: "<" >
+-| < EQ: "==" >
+-| < LE: "<=" >
+-| < GE: ">=" >
+-| < NE: "!=" >
+-| < AND: "&&" >
+-| < OR: "||" >
+-| < PLUS: "+" >
+-| < MINUS:"-" >
+-| < MUL: "*" >
+-| < DOT: "." > // rjm
+-| < DIV: "/" >
+-| < MOD: "%" >
+-| < NOT: "!" >
+-| < POWER:"^" >
+-| < CROSS:"^^" > // rjm
+-| < LSQ: "[" > // rjm
+-| < RSQ: "]" > // rjm
+-| < LRND: "(" > // rjm
+-| < RRND: ")" > // rjm
+-| < COLON: ":" > // rjm
+-}
+-
+-
+-/***************************************************************
+-GRAMMAR START
+-***************************************************************/
+-
+-ASTStart Start() :
+-{/*@bgen(jjtree) Start */
+- ASTStart jjtn000 = new ASTStart(JJTSTART);
+- boolean jjtc000 = true;
+- jjtree.openNodeScope(jjtn000);
+-/*@egen*/
+-}
+-{/*@bgen(jjtree) Start */
+- try {
+-/*@egen*/
+- Expression() ( <EOF> | <SEMI> )/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn000, true);
+- jjtc000 = false;
+- }
+-/*@egen*/ { return jjtn000; }
+- | ( <EOF> | <SEMI> )/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn000, true);
+- jjtc000 = false;
+- }
+-/*@egen*/
+- {
+- // njf - The next line is commented out in 2.3.0 since
+- // two "No expression entered" errors are reported
+- // in EvaluatorVisitor and Console (one from here
+- // the other from ParseStream() )
+- // Decided to just return null, and handle the error
+- // in ParseStream.
+- // addToErrorList("No expression entered");
+- return null;
+- }/*@bgen(jjtree)*/
+- } catch (Throwable jjte000) {
+- if (jjtc000) {
+- jjtree.clearNodeScope(jjtn000);
+- jjtc000 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte000 instanceof RuntimeException) {
+- throw (RuntimeException)jjte000;
+- }
+- if (jjte000 instanceof ParseException) {
+- throw (ParseException)jjte000;
+- }
+- throw (Error)jjte000;
+- } finally {
+- if (jjtc000) {
+- jjtree.closeNodeScope(jjtn000, true);
+- }
+- }
+-/*@egen*/
+-}
+-
+-// Expresions can be like
+-// x=3
+-// x=y=3 parsed as x=(y=3)
+-
+-void Expression() : {}
+-{
+- LOOKAHEAD(LValue() <ASSIGN>) // need to prevent javacc warning with left recusion
+- AssignExpression() // rjm changes from OrExpresion
+- |
+- RightExpression()
+-}
+-
+-void AssignExpression() : {} // rjm addition
+-{/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn001 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc001 = true;
+- jjtree.openNodeScope(jjtn001);
+- }
+- try {
+-/*@egen*/
+-
+- ( LValue() <ASSIGN> Expression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn001, 2);
+- jjtc001 = false;
+- }
+-/*@egen*/
+- {
+- if (!jep.getAllowAssignment()) throw new ParseException(
+- "Syntax Error (assignment not enabled)");
+-
+- jjtn001.setOperator(opSet.getAssign());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte001) {
+- if (jjtc001) {
+- jjtree.clearNodeScope(jjtn001);
+- jjtc001 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte001 instanceof RuntimeException) {
+- throw (RuntimeException)jjte001;
+- }
+- if (jjte001 instanceof ParseException) {
+- throw (ParseException)jjte001;
+- }
+- throw (Error)jjte001;
+- } finally {
+- if (jjtc001) {
+- jjtree.closeNodeScope(jjtn001, 2);
+- }
+- }
+-/*@egen*/
+-}
+-
+-void RightExpression() :
+-{
+-}
+-{
+- OrExpression()
+-}
+-
+-void OrExpression() :
+-{
+-}
+-{
+- AndExpression()
+- (/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn001 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc001 = true;
+- jjtree.openNodeScope(jjtn001);
+- }
+- try {
+-/*@egen*/
+- ( <OR> AndExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn001, 2);
+- jjtc001 = false;
+- }
+-/*@egen*/
+- {
+- jjtn001.setOperator(opSet.getOr());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte001) {
+- if (jjtc001) {
+- jjtree.clearNodeScope(jjtn001);
+- jjtc001 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte001 instanceof RuntimeException) {
+- throw (RuntimeException)jjte001;
+- }
+- if (jjte001 instanceof ParseException) {
+- throw (ParseException)jjte001;
+- }
+- throw (Error)jjte001;
+- } finally {
+- if (jjtc001) {
+- jjtree.closeNodeScope(jjtn001, 2);
+- }
+- }
+-/*@egen*/
+- )*
+-}
+-
+-
+-void AndExpression() :
+-{
+-}
+-{
+- EqualExpression()
+- (/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn001 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc001 = true;
+- jjtree.openNodeScope(jjtn001);
+- }
+- try {
+-/*@egen*/
+- ( <AND> EqualExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn001, 2);
+- jjtc001 = false;
+- }
+-/*@egen*/
+- {
+- jjtn001.setOperator(opSet.getAnd());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte001) {
+- if (jjtc001) {
+- jjtree.clearNodeScope(jjtn001);
+- jjtc001 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte001 instanceof RuntimeException) {
+- throw (RuntimeException)jjte001;
+- }
+- if (jjte001 instanceof ParseException) {
+- throw (ParseException)jjte001;
+- }
+- throw (Error)jjte001;
+- } finally {
+- if (jjtc001) {
+- jjtree.closeNodeScope(jjtn001, 2);
+- }
+- }
+-/*@egen*/
+- )*
+-}
+-
+-
+-
+-void EqualExpression() :
+-{
+-}
+-{
+- RelationalExpression()
+- (/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn001 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc001 = true;
+- jjtree.openNodeScope(jjtn001);
+- }
+- try {
+-/*@egen*/
+- ( <NE> RelationalExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn001, 2);
+- jjtc001 = false;
+- }
+-/*@egen*/
+- {
+- jjtn001.setOperator(opSet.getNE());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte001) {
+- if (jjtc001) {
+- jjtree.clearNodeScope(jjtn001);
+- jjtc001 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte001 instanceof RuntimeException) {
+- throw (RuntimeException)jjte001;
+- }
+- if (jjte001 instanceof ParseException) {
+- throw (ParseException)jjte001;
+- }
+- throw (Error)jjte001;
+- } finally {
+- if (jjtc001) {
+- jjtree.closeNodeScope(jjtn001, 2);
+- }
+- }
+-/*@egen*/
+- |/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn002 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc002 = true;
+- jjtree.openNodeScope(jjtn002);
+- }
+- try {
+-/*@egen*/
+- ( <EQ> RelationalExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn002, 2);
+- jjtc002 = false;
+- }
+-/*@egen*/
+- {
+- jjtn002.setOperator(opSet.getEQ());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte002) {
+- if (jjtc002) {
+- jjtree.clearNodeScope(jjtn002);
+- jjtc002 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte002 instanceof RuntimeException) {
+- throw (RuntimeException)jjte002;
+- }
+- if (jjte002 instanceof ParseException) {
+- throw (ParseException)jjte002;
+- }
+- throw (Error)jjte002;
+- } finally {
+- if (jjtc002) {
+- jjtree.closeNodeScope(jjtn002, 2);
+- }
+- }
+-/*@egen*/
+- )*
+-}
+-
+-
+-
+-void RelationalExpression() :
+-{
+-}
+-{
+- AdditiveExpression()
+- (/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn001 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc001 = true;
+- jjtree.openNodeScope(jjtn001);
+- }
+- try {
+-/*@egen*/
+- ( <LT> AdditiveExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn001, 2);
+- jjtc001 = false;
+- }
+-/*@egen*/
+- {
+- jjtn001.setOperator(opSet.getLT());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte001) {
+- if (jjtc001) {
+- jjtree.clearNodeScope(jjtn001);
+- jjtc001 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte001 instanceof RuntimeException) {
+- throw (RuntimeException)jjte001;
+- }
+- if (jjte001 instanceof ParseException) {
+- throw (ParseException)jjte001;
+- }
+- throw (Error)jjte001;
+- } finally {
+- if (jjtc001) {
+- jjtree.closeNodeScope(jjtn001, 2);
+- }
+- }
+-/*@egen*/
+- |/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn002 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc002 = true;
+- jjtree.openNodeScope(jjtn002);
+- }
+- try {
+-/*@egen*/
+- ( <GT> AdditiveExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn002, 2);
+- jjtc002 = false;
+- }
+-/*@egen*/
+- {
+- jjtn002.setOperator(opSet.getGT());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte002) {
+- if (jjtc002) {
+- jjtree.clearNodeScope(jjtn002);
+- jjtc002 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte002 instanceof RuntimeException) {
+- throw (RuntimeException)jjte002;
+- }
+- if (jjte002 instanceof ParseException) {
+- throw (ParseException)jjte002;
+- }
+- throw (Error)jjte002;
+- } finally {
+- if (jjtc002) {
+- jjtree.closeNodeScope(jjtn002, 2);
+- }
+- }
+-/*@egen*/
+- |/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn003 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc003 = true;
+- jjtree.openNodeScope(jjtn003);
+- }
+- try {
+-/*@egen*/
+- ( <LE> AdditiveExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn003, 2);
+- jjtc003 = false;
+- }
+-/*@egen*/
+- {
+- jjtn003.setOperator(opSet.getLE());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte003) {
+- if (jjtc003) {
+- jjtree.clearNodeScope(jjtn003);
+- jjtc003 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte003 instanceof RuntimeException) {
+- throw (RuntimeException)jjte003;
+- }
+- if (jjte003 instanceof ParseException) {
+- throw (ParseException)jjte003;
+- }
+- throw (Error)jjte003;
+- } finally {
+- if (jjtc003) {
+- jjtree.closeNodeScope(jjtn003, 2);
+- }
+- }
+-/*@egen*/
+- |/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn004 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc004 = true;
+- jjtree.openNodeScope(jjtn004);
+- }
+- try {
+-/*@egen*/
+- ( <GE> AdditiveExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn004, 2);
+- jjtc004 = false;
+- }
+-/*@egen*/
+- {
+- jjtn004.setOperator(opSet.getGE());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte004) {
+- if (jjtc004) {
+- jjtree.clearNodeScope(jjtn004);
+- jjtc004 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte004 instanceof RuntimeException) {
+- throw (RuntimeException)jjte004;
+- }
+- if (jjte004 instanceof ParseException) {
+- throw (ParseException)jjte004;
+- }
+- throw (Error)jjte004;
+- } finally {
+- if (jjtc004) {
+- jjtree.closeNodeScope(jjtn004, 2);
+- }
+- }
+-/*@egen*/
+- )*
+-}
+-
+-
+-void AdditiveExpression() :
+-{
+-}
+-{
+- MultiplicativeExpression()
+- (/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn001 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc001 = true;
+- jjtree.openNodeScope(jjtn001);
+- }
+- try {
+-/*@egen*/
+- ( <PLUS> MultiplicativeExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn001, 2);
+- jjtc001 = false;
+- }
+-/*@egen*/
+- {
+- jjtn001.setOperator(opSet.getAdd());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte001) {
+- if (jjtc001) {
+- jjtree.clearNodeScope(jjtn001);
+- jjtc001 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte001 instanceof RuntimeException) {
+- throw (RuntimeException)jjte001;
+- }
+- if (jjte001 instanceof ParseException) {
+- throw (ParseException)jjte001;
+- }
+- throw (Error)jjte001;
+- } finally {
+- if (jjtc001) {
+- jjtree.closeNodeScope(jjtn001, 2);
+- }
+- }
+-/*@egen*/
+- |/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn002 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc002 = true;
+- jjtree.openNodeScope(jjtn002);
+- }
+- try {
+-/*@egen*/
+- ( <MINUS> MultiplicativeExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn002, 2);
+- jjtc002 = false;
+- }
+-/*@egen*/
+- {
+- jjtn002.setOperator(opSet.getSubtract());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte002) {
+- if (jjtc002) {
+- jjtree.clearNodeScope(jjtn002);
+- jjtc002 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte002 instanceof RuntimeException) {
+- throw (RuntimeException)jjte002;
+- }
+- if (jjte002 instanceof ParseException) {
+- throw (ParseException)jjte002;
+- }
+- throw (Error)jjte002;
+- } finally {
+- if (jjtc002) {
+- jjtree.closeNodeScope(jjtn002, 2);
+- }
+- }
+-/*@egen*/
+- )*
+-}
+-
+-
+-void MultiplicativeExpression() :
+-{
+-}
+-{
+- UnaryExpression()
+- (/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn001 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc001 = true;
+- jjtree.openNodeScope(jjtn001);
+- }
+- try {
+-/*@egen*/
+- (
+- PowerExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn001, 2);
+- jjtc001 = false;
+- }
+-/*@egen*/
+- {
+- if (!jep.implicitMul) throw new ParseException(
+- "Syntax Error (implicit multiplication not enabled)");
+-
+- jjtn001.setOperator(opSet.getMultiply());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte001) {
+- if (jjtc001) {
+- jjtree.clearNodeScope(jjtn001);
+- jjtc001 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte001 instanceof RuntimeException) {
+- throw (RuntimeException)jjte001;
+- }
+- if (jjte001 instanceof ParseException) {
+- throw (ParseException)jjte001;
+- }
+- throw (Error)jjte001;
+- } finally {
+- if (jjtc001) {
+- jjtree.closeNodeScope(jjtn001, 2);
+- }
+- }
+-/*@egen*/
+- |/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn002 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc002 = true;
+- jjtree.openNodeScope(jjtn002);
+- }
+- try {
+-/*@egen*/
+- ( <MUL> UnaryExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn002, 2);
+- jjtc002 = false;
+- }
+-/*@egen*/
+- {
+- jjtn002.setOperator(opSet.getMultiply());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte002) {
+- if (jjtc002) {
+- jjtree.clearNodeScope(jjtn002);
+- jjtc002 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte002 instanceof RuntimeException) {
+- throw (RuntimeException)jjte002;
+- }
+- if (jjte002 instanceof ParseException) {
+- throw (ParseException)jjte002;
+- }
+- throw (Error)jjte002;
+- } finally {
+- if (jjtc002) {
+- jjtree.closeNodeScope(jjtn002, 2);
+- }
+- }
+-/*@egen*/
+- |/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn003 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc003 = true;
+- jjtree.openNodeScope(jjtn003);
+- }
+- try {
+-/*@egen*/
+- ( <DOT> UnaryExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn003, 2);
+- jjtc003 = false;
+- }
+-/*@egen*/
+- {
+- jjtn003.setOperator(opSet.getDot());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte003) {
+- if (jjtc003) {
+- jjtree.clearNodeScope(jjtn003);
+- jjtc003 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte003 instanceof RuntimeException) {
+- throw (RuntimeException)jjte003;
+- }
+- if (jjte003 instanceof ParseException) {
+- throw (ParseException)jjte003;
+- }
+- throw (Error)jjte003;
+- } finally {
+- if (jjtc003) {
+- jjtree.closeNodeScope(jjtn003, 2);
+- }
+- }
+-/*@egen*/
+- |/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn004 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc004 = true;
+- jjtree.openNodeScope(jjtn004);
+- }
+- try {
+-/*@egen*/
+- ( <CROSS> UnaryExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn004, 2);
+- jjtc004 = false;
+- }
+-/*@egen*/
+- {
+- jjtn004.setOperator(opSet.getCross());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte004) {
+- if (jjtc004) {
+- jjtree.clearNodeScope(jjtn004);
+- jjtc004 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte004 instanceof RuntimeException) {
+- throw (RuntimeException)jjte004;
+- }
+- if (jjte004 instanceof ParseException) {
+- throw (ParseException)jjte004;
+- }
+- throw (Error)jjte004;
+- } finally {
+- if (jjtc004) {
+- jjtree.closeNodeScope(jjtn004, 2);
+- }
+- }
+-/*@egen*/
+- |/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn005 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc005 = true;
+- jjtree.openNodeScope(jjtn005);
+- }
+- try {
+-/*@egen*/
+- ( <DIV> UnaryExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn005, 2);
+- jjtc005 = false;
+- }
+-/*@egen*/
+- {
+- jjtn005.setOperator(opSet.getDivide());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte005) {
+- if (jjtc005) {
+- jjtree.clearNodeScope(jjtn005);
+- jjtc005 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte005 instanceof RuntimeException) {
+- throw (RuntimeException)jjte005;
+- }
+- if (jjte005 instanceof ParseException) {
+- throw (ParseException)jjte005;
+- }
+- throw (Error)jjte005;
+- } finally {
+- if (jjtc005) {
+- jjtree.closeNodeScope(jjtn005, 2);
+- }
+- }
+-/*@egen*/
+- |/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn006 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc006 = true;
+- jjtree.openNodeScope(jjtn006);
+- }
+- try {
+-/*@egen*/
+- ( <MOD> UnaryExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn006, 2);
+- jjtc006 = false;
+- }
+-/*@egen*/
+- {
+- jjtn006.setOperator(opSet.getMod());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte006) {
+- if (jjtc006) {
+- jjtree.clearNodeScope(jjtn006);
+- jjtc006 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte006 instanceof RuntimeException) {
+- throw (RuntimeException)jjte006;
+- }
+- if (jjte006 instanceof ParseException) {
+- throw (ParseException)jjte006;
+- }
+- throw (Error)jjte006;
+- } finally {
+- if (jjtc006) {
+- jjtree.closeNodeScope(jjtn006, 2);
+- }
+- }
+-/*@egen*/
+- )*
+-}
+-
+-
+-void UnaryExpression() :
+-{
+-}
+-{
+- ( <PLUS> UnaryExpression())
+-|/*@bgen(jjtree) #FunNode( 1) */
+- {
+- ASTFunNode jjtn001 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc001 = true;
+- jjtree.openNodeScope(jjtn001);
+- }
+- try {
+-/*@egen*/
+- ( <MINUS> UnaryExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn001, 1);
+- jjtc001 = false;
+- }
+-/*@egen*/
+- {
+- jjtn001.setOperator(opSet.getUMinus());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte001) {
+- if (jjtc001) {
+- jjtree.clearNodeScope(jjtn001);
+- jjtc001 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte001 instanceof RuntimeException) {
+- throw (RuntimeException)jjte001;
+- }
+- if (jjte001 instanceof ParseException) {
+- throw (ParseException)jjte001;
+- }
+- throw (Error)jjte001;
+- } finally {
+- if (jjtc001) {
+- jjtree.closeNodeScope(jjtn001, 1);
+- }
+- }
+-/*@egen*/
+-|/*@bgen(jjtree) #FunNode( 1) */
+- {
+- ASTFunNode jjtn002 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc002 = true;
+- jjtree.openNodeScope(jjtn002);
+- }
+- try {
+-/*@egen*/
+- ( <NOT> UnaryExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn002, 1);
+- jjtc002 = false;
+- }
+-/*@egen*/
+- {
+- jjtn002.setOperator(opSet.getNot());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte002) {
+- if (jjtc002) {
+- jjtree.clearNodeScope(jjtn002);
+- jjtc002 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte002 instanceof RuntimeException) {
+- throw (RuntimeException)jjte002;
+- }
+- if (jjte002 instanceof ParseException) {
+- throw (ParseException)jjte002;
+- }
+- throw (Error)jjte002;
+- } finally {
+- if (jjtc002) {
+- jjtree.closeNodeScope(jjtn002, 1);
+- }
+- }
+-/*@egen*/
+-|
+- PowerExpression()
+-}
+-
+-
+-void PowerExpression() :
+-{
+-}
+-{
+- UnaryExpressionNotPlusMinus()
+- [/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn001 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc001 = true;
+- jjtree.openNodeScope(jjtn001);
+- }
+- try {
+-/*@egen*/
+- ( <POWER> UnaryExpression()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn001, 2);
+- jjtc001 = false;
+- }
+-/*@egen*/
+- {
+- jjtn001.setOperator(opSet.getPower());
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte001) {
+- if (jjtc001) {
+- jjtree.clearNodeScope(jjtn001);
+- jjtc001 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte001 instanceof RuntimeException) {
+- throw (RuntimeException)jjte001;
+- }
+- if (jjte001 instanceof ParseException) {
+- throw (ParseException)jjte001;
+- }
+- throw (Error)jjte001;
+- } finally {
+- if (jjtc001) {
+- jjtree.closeNodeScope(jjtn001, 2);
+- }
+- }
+-/*@egen*/
+- ]
+-}
+-
+-
+-void UnaryExpressionNotPlusMinus() :
+-{
+- String identString = "";
+- int type;
+-}
+-{
+- AnyConstant()
+- |
+- LOOKAHEAD(ArrayAccess())
+- ArrayAccess()
+- |
+- LOOKAHEAD({ (getToken(1).kind == INDENTIFIER1 || getToken(1).kind == INDENTIFIER2) &&
+- jep.funTab.containsKey(getToken(1).image) })
+- Function()
+- |
+- Variable()
+- |
+- <LRND> Expression() <RRND>
+- |
+-// LOOKAHEAD(<LSQ> Expression() <COLON>)
+-// RangeExpression()
+-// |
+- ListExpression()
+-}
+-
+-void ListExpression() :
+-{/*@bgen(jjtree) FunNode */
+- ASTFunNode jjtn000 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc000 = true;
+- jjtree.openNodeScope(jjtn000);
+-/*@egen*/
+- jjtn000.setOperator(opSet.getList());
+-}
+-{/*@bgen(jjtree) FunNode */
+- try {
+-/*@egen*/
+- <LSQ> Expression() ( <COMMA> Expression() )* <RSQ>/*@bgen(jjtree)*/
+- } catch (Throwable jjte000) {
+- if (jjtc000) {
+- jjtree.clearNodeScope(jjtn000);
+- jjtc000 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte000 instanceof RuntimeException) {
+- throw (RuntimeException)jjte000;
+- }
+- if (jjte000 instanceof ParseException) {
+- throw (ParseException)jjte000;
+- }
+- throw (Error)jjte000;
+- } finally {
+- if (jjtc000) {
+- jjtree.closeNodeScope(jjtn000, true);
+- }
+- }
+-/*@egen*/
+-}
+-
+-/*
+-void RangeExpression() #FunNode:
+-{
+- jjtThis.setOperator(opSet.getRange());
+-}
+-{
+- <LSQ> Expression() ( <COLON> Expression() )+ <RSQ>
+-}
+-*/
+-
+-void LValue() :
+-{
+-}
+-{
+- LOOKAHEAD(ArrayAccess())
+- ArrayAccess()
+- | Variable()
+-}
+-
+-void ArrayAccess() :
+-{
+-}
+-{
+- Variable() ListExpression()/*@bgen(jjtree) #FunNode( 2) */
+- {
+- ASTFunNode jjtn001 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc001 = true;
+- jjtree.openNodeScope(jjtn001);
+- }
+- try {
+-/*@egen*//*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn001, 2);
+- jjtc001 = false;
+- }
+-/*@egen*/
+- {
+- jjtn001.setOperator(opSet.getElement());
+- }/*@bgen(jjtree)*/
+- } finally {
+- if (jjtc001) {
+- jjtree.closeNodeScope(jjtn001, 2);
+- }
+- }
+-/*@egen*/
+-
+-}
+-void Variable() :
+-{
+- String identString = "";
+-}
+-{/*@bgen(jjtree) VarNode */
+- {
+- ASTVarNode jjtn001 = new ASTVarNode(JJTVARNODE);
+- boolean jjtc001 = true;
+- jjtree.openNodeScope(jjtn001);
+- }
+- try {
+-/*@egen*/
+- (identString = Identifier()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn001, true);
+- jjtc001 = false;
+- }
+-/*@egen*/
+- {
+- if (symTab.containsKey(identString)) {
+- jjtn001.setVar(symTab.getVar(identString));
+- } else {
+- if (jep.allowUndeclared) {
+- jjtn001.setVar(symTab.makeVarIfNeeded(identString));
+- } else {
+- addToErrorList("Unrecognized symbol \"" + identString +"\"");
+- }
+- }
+- }
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte001) {
+- if (jjtc001) {
+- jjtree.clearNodeScope(jjtn001);
+- jjtc001 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte001 instanceof RuntimeException) {
+- throw (RuntimeException)jjte001;
+- }
+- if (jjte001 instanceof ParseException) {
+- throw (ParseException)jjte001;
+- }
+- throw (Error)jjte001;
+- } finally {
+- if (jjtc001) {
+- jjtree.closeNodeScope(jjtn001, true);
+- }
+- }
+-/*@egen*/
+-}
+-
+-
+-
+-void Function() :
+-{
+- int reqArguments = 0;
+- String identString = "";
+-}
+-{/*@bgen(jjtree) FunNode */
+- {
+- ASTFunNode jjtn001 = new ASTFunNode(JJTFUNNODE);
+- boolean jjtc001 = true;
+- jjtree.openNodeScope(jjtn001);
+- }
+- try {
+-/*@egen*/
+- ( identString = Identifier()
+- {
+- if (jep.funTab.containsKey(identString)) {
+- //Set number of required arguments
+- reqArguments =
+- ((PostfixMathCommandI)jep.funTab.get(identString)).getNumberOfParameters();
+- jjtn001.setFunction(identString,
+- (PostfixMathCommandI)jep.funTab.get(identString));
+- } else {
+- addToErrorList("!!! Unrecognized function \"" + identString +"\"");
+- }
+- }
+-
+- <LRND> ArgumentList(reqArguments, identString) <RRND>
+-
+- )/*@bgen(jjtree)*/
+- } catch (Throwable jjte001) {
+- if (jjtc001) {
+- jjtree.clearNodeScope(jjtn001);
+- jjtc001 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte001 instanceof RuntimeException) {
+- throw (RuntimeException)jjte001;
+- }
+- if (jjte001 instanceof ParseException) {
+- throw (ParseException)jjte001;
+- }
+- throw (Error)jjte001;
+- } finally {
+- if (jjtc001) {
+- jjtree.closeNodeScope(jjtn001, true);
+- }
+- }
+-/*@egen*/
+-}
+-
+-void ArgumentList(int reqArguments, String functionName) :
+-{
+- int count = 0;
+- String errorStr = "";
+-}
+-{
+- [
+- Expression() { count++; }
+- (
+- <COMMA>
+- Expression() { count++; }
+- )*
+- ]
+- {
+- if(reqArguments == -1) {
+- if(!((PostfixMathCommandI)jep.funTab.get(functionName)).checkNumberOfParameters(count))
+- {
+- errorStr = "Function \"" + functionName +"\" illegal number of arguments " + count;
+- addToErrorList(errorStr);
+- }
+- }
+- else if (reqArguments != count) {
+- errorStr = "Function \"" + functionName +"\" requires "
+- + reqArguments + " parameter";
+- if (reqArguments!=1) errorStr += "s";
+- addToErrorList(errorStr);
+- }
+- }
+-}
+-
+-
+-
+-String Identifier() :
+-{
+- Token t;
+-}
+-{
+- ( t = <INDENTIFIER1> | t = <INDENTIFIER2> ) { return t.image; }
+-}
+-
+-
+-void AnyConstant() :
+-{/*@bgen(jjtree) Constant */
+- ASTConstant jjtn000 = new ASTConstant(JJTCONSTANT);
+- boolean jjtc000 = true;
+- jjtree.openNodeScope(jjtn000);
+-/*@egen*/
+- Token t;
+- Object value;
+-}
+-{/*@bgen(jjtree) Constant */
+- try {
+-/*@egen*/
+- t=<STRING_LITERAL>/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn000, true);
+- jjtc000 = false;
+- }
+-/*@egen*/ {
+- // strip away double quotes at end of string
+- String temp = (t.image).substring(1,t.image.length()-1);
+-
+- // replace escape characters
+- temp = replaceEscape(temp);
+-
+- jjtn000.setValue(temp);
+- }
+- |
+- value = RealConstant()/*@bgen(jjtree)*/
+- {
+- jjtree.closeNodeScope(jjtn000, true);
+- jjtc000 = false;
+- }
+-/*@egen*/ {
+- jjtn000.setValue(value);
+-// }
+-// |
+-// value = Array() {
+-// jjtThis.setValue(value);
+- }/*@bgen(jjtree)*/
+- } catch (Throwable jjte000) {
+- if (jjtc000) {
+- jjtree.clearNodeScope(jjtn000);
+- jjtc000 = false;
+- } else {
+- jjtree.popNode();
+- }
+- if (jjte000 instanceof RuntimeException) {
+- throw (RuntimeException)jjte000;
+- }
+- if (jjte000 instanceof ParseException) {
+- throw (ParseException)jjte000;
+- }
+- throw (Error)jjte000;
+- } finally {
+- if (jjtc000) {
+- jjtree.closeNodeScope(jjtn000, true);
+- }
+- }
+-/*@egen*/
+-}
+-
+-/*
+-Vector Array() :
+-{
+- Object value;
+- Vector result = new Vector();
+-}
+-{
+- <LSQ>
+- value = RealConstant()
+- {
+- result.addElement(value);
+- }
+- (
+- <COMMA>
+- value = RealConstant()
+- {
+- result.addElement(value);
+- }
+- )*
+- <RSQ>
+- {
+- return result;
+- }
+-}
+-*/
+-
+-
+-
+-
+-Object RealConstant() :
+-{
+- Token t;
+- Object value;
+-}
+-{
+- (t=<INTEGER_LITERAL> | t=<FLOATING_POINT_LITERAL>)
+- {
+- try {
+- value = jep.getNumberFactory().createNumber(t.image);
+- } catch (Exception e) {
+- value = null;
+- addToErrorList("Can't parse \"" + t.image + "\"");
+- }
+-
+- return value;
+- }
+-}
=====================================
debian/patches/series
=====================================
@@ -1 +1,2 @@
runtests.patch
+remove-prebuilt-files.patch
=====================================
debian/rules
=====================================
@@ -9,17 +9,12 @@ export JAVACCHOME=/usr/share/java
export CLASSPATH=/usr/share/java/jama.jar
UPSTREAM_VER := $(shell echo $(DEB_VERSION_UPSTREAM) | cut -d + -f 1)
-JQUERY_DIR = $(CURDIR)/debian/libjep-java-doc/usr/share/doc/libjep-java-doc/api/jquery
%:
dh $@ --with javahelper
override_dh_auto_build:
- mkdir debian/old
- mv src/org/nfunk/jep/Token.java src/org/nfunk/jep/TokenMgrError.java \
- src/org/nfunk/jep/JavaCharStream.java src/org/nfunk/jep/ParseException.java \
- debian/old/
- dh_auto_build -- jar javadoc
+ dh_auto_build -- jar
ifeq (,$(filter nocheck,$(DEB_BUILD_OPTIONS)))
override_dh_auto_test:
@@ -28,17 +23,3 @@ endif
override_jh_installlibs:
jh_installlibs dist/jep-$(UPSTREAM_VER).jar
-
-override_dh_installdocs:
- dh_installdocs
- ln -fs /usr/share/javascript/jquery/jquery.js ${JQUERY_DIR}/external/jquery/jquery.js
- ln -fs /usr/share/javascript/jquery/jquery.js ${JQUERY_DIR}/jquery-3*.js
- ln -fs /usr/share/javascript/jquery-ui/themes/base/jquery-ui.css ${JQUERY_DIR}/jquery-ui.css
- ln -fs /usr/share/javascript/jquery-ui/jquery-ui.js ${JQUERY_DIR}/jquery-ui.js
- ln -fs /usr/share/javascript/jquery-ui/themes/base/jquery-ui.min.css ${JQUERY_DIR}/jquery-ui.min.css
- ln -fs /usr/share/javascript/jquery-ui/jquery-ui.min.js ${JQUERY_DIR}/jquery-ui.min.js
-
-override_dh_clean:
- -find debian/old -name '*.java' | xargs -i mv {} src/org/nfunk/jep/
- rm -rf doc/javadoc debian/old
- dh_clean
View it on GitLab: https://salsa.debian.org/java-team/jep/compare/dc71f7fd4989acdbb5f67f11c7e3bb605855631a...c47d356f09102d74b36c2fe14fe7c36d6178387e
--
View it on GitLab: https://salsa.debian.org/java-team/jep/compare/dc71f7fd4989acdbb5f67f11c7e3bb605855631a...c47d356f09102d74b36c2fe14fe7c36d6178387e
You're receiving this email because of your account on salsa.debian.org.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://alioth-lists.debian.net/pipermail/pkg-java-commits/attachments/20191118/562d9cbc/attachment.html>
More information about the pkg-java-commits
mailing list