==== Patch level 1 Source: [No source] Target: 737f8f2c-97f8-0310-ac9b-cfac8cc1a2f5:/eng/third-party/janino/trunk:72702 (svn+ssh://svn.streambase.com/repos/sb) Log: r74520@spiceweasel (orig r72709): fowles | 2008-05-23 11:28:22 -0400 Fix an issue with the handling of negative constants === tests/src/UnparseTests.java ================================================================== --- tests/src/UnparseTests.java (revision 72702) +++ tests/src/UnparseTests.java (patch unparse-fix level 1) @@ -1,480 +1,513 @@ - -/* - * Janino - An embedded Java[TM] compiler - * - * Copyright (c) 2001-2007, Arno Unkrig - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials - * provided with the distribution. - * 3. The name of the author may not be used to endorse or promote - * products derived from this software without specific prior - * written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER - * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.File; -import java.io.FileFilter; -import java.io.FileInputStream; -import java.io.InputStream; -import java.io.OutputStreamWriter; -import java.io.StringReader; -import java.io.StringWriter; -import java.util.ArrayList; -import java.util.List; -import junit.framework.Assert; -import junit.framework.Test; -import junit.framework.TestCase; -import junit.framework.TestSuite; - -import org.codehaus.janino.Java; -import org.codehaus.janino.Parser; -import org.codehaus.janino.Scanner; -import org.codehaus.janino.UnparseVisitor; -import org.codehaus.janino.Visitor; -import org.codehaus.janino.Java.AbstractTypeDeclaration; -import org.codehaus.janino.Java.AmbiguousName; -import org.codehaus.janino.Java.ArrayAccessExpression; -import org.codehaus.janino.Java.ArrayLength; -import org.codehaus.janino.Java.Assignment; -import org.codehaus.janino.Java.Atom; -import org.codehaus.janino.Java.BinaryOperation; -import org.codehaus.janino.Java.Cast; -import org.codehaus.janino.Java.ClassLiteral; -import org.codehaus.janino.Java.CompilationUnit; -import org.codehaus.janino.Java.ConditionalExpression; -import org.codehaus.janino.Java.ConstantValue; -import org.codehaus.janino.Java.Crement; -import org.codehaus.janino.Java.FieldAccess; -import org.codehaus.janino.Java.FieldAccessExpression; -import org.codehaus.janino.Java.Instanceof; -import org.codehaus.janino.Java.Literal; -import org.codehaus.janino.Java.LocalVariableAccess; -import org.codehaus.janino.Java.Locatable; -import org.codehaus.janino.Java.Located; -import org.codehaus.janino.Java.MethodInvocation; -import org.codehaus.janino.Java.NewAnonymousClassInstance; -import org.codehaus.janino.Java.NewArray; -import org.codehaus.janino.Java.NewClassInstance; -import org.codehaus.janino.Java.NewInitializedArray; -import org.codehaus.janino.Java.ParameterAccess; -import org.codehaus.janino.Java.ParenthesizedExpression; -import org.codehaus.janino.Java.QualifiedThisReference; -import org.codehaus.janino.Java.SuperclassFieldAccessExpression; -import org.codehaus.janino.Java.SuperclassMethodInvocation; -import org.codehaus.janino.Java.ThisReference; -import org.codehaus.janino.Java.UnaryOperation; -import org.codehaus.janino.util.Traverser; - -public class UnparseTests extends TestCase { - public static Test suite() { - TestSuite s = new TestSuite(UnparseTests.class.getName()); - s.addTest(new UnparseTests("testSimple")); - s.addTest(new UnparseTests("testParens")); - s.addTest(new UnparseTests("testMany")); - s.addTest(new UnparseTests("testParseUnparseParseJanino")); - return s; - } - - public UnparseTests(String name) { super(name); } - - private static void helpTestExpr(String input, String expect, boolean simplify) throws Exception { - Parser p = new Parser(new Scanner(null, new StringReader(input))); - Atom expr = p.parseExpression(); - if (simplify) { - expr = UnparseTests.stripUnnecessaryParenExprs(expr); - } - - StringWriter sw = new StringWriter(); - UnparseVisitor uv = new UnparseVisitor(sw); - expr.accept(uv); - String s = sw.toString(); - s = UnparseTests.replace(s, "((( ", "("); - s = UnparseTests.replace(s, " )))", ")"); - Assert.assertEquals(expect, s); - } - private static String replace(String s, String from, String to) { - for (;;) { - int idx = s.indexOf(from); - if (idx == -1) break; - s = s.substring(0, idx) + to + s.substring(idx + from.length()); - } - return s; - } - - private static Java.Rvalue[] stripUnnecessaryParenExprs(Java.Rvalue[] rvalues) { - Java.Rvalue[] res = new Java.Rvalue[rvalues.length]; - for(int i = 0; i < res.length; ++i) { - res[i] = UnparseTests.stripUnnecessaryParenExprs(rvalues[i]); - } - return res; - } - - private static Java.Atom stripUnnecessaryParenExprs(Java.Atom atom) { - if (atom instanceof Java.Rvalue) { - return UnparseTests.stripUnnecessaryParenExprs((Java.Rvalue)atom); - } - return atom; - } - - private static Java.Lvalue stripUnnecessaryParenExprs(Java.Lvalue lvalue) { - return (Java.Lvalue)UnparseTests.stripUnnecessaryParenExprs((Java.Rvalue)lvalue); - } - - private static Java.Rvalue stripUnnecessaryParenExprs(Java.Rvalue rvalue) { - if (rvalue == null) { return null; } - final Java.Rvalue[] res = new Java.Rvalue[1]; - Visitor.RvalueVisitor rv = new Visitor.RvalueVisitor() { - public void visitArrayLength(ArrayLength al) { - res[0] = new Java.ArrayLength( - al.getLocation(), - UnparseTests.stripUnnecessaryParenExprs(al.lhs) - ); - } - - public void visitAssignment(Assignment a) { - res[0] = new Java.Assignment( - a.getLocation(), - UnparseTests.stripUnnecessaryParenExprs(a.lhs), - a.operator, - UnparseTests.stripUnnecessaryParenExprs(a.rhs) - ); - } - - public void visitBinaryOperation(BinaryOperation bo) { - res[0] = new Java.BinaryOperation( - bo.getLocation(), - UnparseTests.stripUnnecessaryParenExprs(bo.lhs), - bo.op, - UnparseTests.stripUnnecessaryParenExprs(bo.rhs) - ); - } - - public void visitCast(Cast c) { - res[0] = new Java.Cast( - c.getLocation(), - c.targetType, - UnparseTests.stripUnnecessaryParenExprs(c.value) - ); - } - - public void visitClassLiteral(ClassLiteral cl) { - res[0] = cl; //too much effort - } - - public void visitConditionalExpression(ConditionalExpression ce) { - res[0] = new Java.ConditionalExpression( - ce.getLocation(), - UnparseTests.stripUnnecessaryParenExprs(ce.lhs), - UnparseTests.stripUnnecessaryParenExprs(ce.mhs), - UnparseTests.stripUnnecessaryParenExprs(ce.rhs) - ); - } - - public void visitConstantValue(ConstantValue cv) { - res[0] = cv; - } - - public void visitCrement(Crement c) { - if (c.pre) { - res[0] = new Java.Crement( - c.getLocation(), - c.operator, - UnparseTests.stripUnnecessaryParenExprs(c.operand) - ); - } else { - res[0] = new Java.Crement( - c.getLocation(), - UnparseTests.stripUnnecessaryParenExprs(c.operand), - c.operator - ); - } - } - - public void visitInstanceof(Instanceof io) { - res[0] = new Java.Instanceof( - io.getLocation(), - UnparseTests.stripUnnecessaryParenExprs(io.lhs), - io.rhs - ); - } - - public void visitLiteral(Literal l) { - res[0] = l; - } - - public void visitMethodInvocation(MethodInvocation mi) { - res[0] = new Java.MethodInvocation( - mi.getLocation(), - UnparseTests.stripUnnecessaryParenExprs(mi.optionalTarget), - mi.methodName, - UnparseTests.stripUnnecessaryParenExprs(mi.arguments) - ); - } - - public void visitNewAnonymousClassInstance(NewAnonymousClassInstance naci) { - res[0] = naci; //too much effort - } - - public void visitNewArray(NewArray na) { - res[0] = new Java.NewArray( - na.getLocation(), - na.type, - UnparseTests.stripUnnecessaryParenExprs(na.dimExprs), - na.dims - ); - } - - public void visitNewClassInstance(NewClassInstance nci) { - res[0] = new Java.NewClassInstance( - nci.getLocation(), - UnparseTests.stripUnnecessaryParenExprs(nci.optionalQualification), - nci.type, - UnparseTests.stripUnnecessaryParenExprs(nci.arguments) - ); - } - - public void visitNewInitializedArray(NewInitializedArray nia) { - res[0] = nia; //too much effort - } - - public void visitParameterAccess(ParameterAccess pa) { - res[0] = pa; - } - - public void visitQualifiedThisReference(QualifiedThisReference qtr) { - res[0] = qtr; - } - - public void visitSuperclassMethodInvocation(SuperclassMethodInvocation smi) { - res[0] = new Java.SuperclassMethodInvocation( - smi.getLocation(), - smi.methodName, - UnparseTests.stripUnnecessaryParenExprs(smi.arguments) - ); - } - - public void visitThisReference(ThisReference tr) { - res[0] = tr; - } - - public void visitUnaryOperation(UnaryOperation uo) { - res[0] = new Java.UnaryOperation( - uo.getLocation(), - uo.operator, - UnparseTests.stripUnnecessaryParenExprs(uo.operand) - ); - } - - public void visitAmbiguousName(AmbiguousName an) { - res[0] = an; - } - - public void visitArrayAccessExpression(ArrayAccessExpression aae) { - res[0] = new Java.ArrayAccessExpression( - aae.getLocation(), - UnparseTests.stripUnnecessaryParenExprs(aae.lhs), - UnparseTests.stripUnnecessaryParenExprs(aae.index) - ); - } - - public void visitFieldAccess(FieldAccess fa) { - res[0] = new Java.FieldAccess( - fa.getLocation(), - UnparseTests.stripUnnecessaryParenExprs(fa.lhs), - fa.field - ); - } - - public void visitFieldAccessExpression(FieldAccessExpression fae) { - res[0] = new Java.FieldAccessExpression( - fae.getLocation(), - UnparseTests.stripUnnecessaryParenExprs(fae.lhs), - fae.fieldName - ); - } - - public void visitLocalVariableAccess(LocalVariableAccess lva) { - res[0] = lva; - } - - public void visitParenthesizedExpression(ParenthesizedExpression pe) { - res[0] = UnparseTests.stripUnnecessaryParenExprs(pe.value); - } - - public void visitSuperclassFieldAccessExpression(SuperclassFieldAccessExpression scfae) { - res[0] = scfae; - } - - }; - rvalue.accept(rv); - return res[0]; - } - - public void testSimple() throws Exception { - UnparseTests.helpTestExpr("1 + 2*3", "1 + 2 * 3", false); - UnparseTests.helpTestExpr("1 + 2*3", "1 + 2 * 3", true); - } - - public void testParens() throws Exception { - UnparseTests.helpTestExpr("(1 + 2)*3", "(1 + 2) * 3", false); - UnparseTests.helpTestExpr("(1 + 2)*3", "(1 + 2) * 3", true); - } - - public void testMany() throws Exception { - final String[][] exprs = new String[][] { - //input expected simplified expect non-simplified - { "((1)+2)", "1 + 2", "((1) + 2)" }, - { "1 - 2 + 3", null, null }, - { "(1 - 2) + 3", "1 - 2 + 3", null }, - { "1 - (2 + 3)", "1 - (2 + 3)", null }, - { "1 + 2 * 3", null, null }, - { "1 + (2 * 3)", "1 + 2 * 3", null }, - { "3 - (2 - 1)", null, null }, - { "true ? 1 : 2", null, null }, - { "(true ? false : true) ? 1 : 2", null, null }, - { "true ? false : (true ? false : true)", "true ? false : true ? false : true", null }, - { "-(-(2))", "-(-2)", "-(-(2))" }, - { "- - 2", "-(-2)", "-(-2)" }, - { "x && (y || z)", null, null }, - { "(x && y) || z", "x && y || z", null }, - { "x = (y = z)", "x = y = z", null }, - { "x *= (y *= z)", "x *= y *= z", null }, - { "(--x) + 3", "--x + 3", null }, - { "(baz.bar).foo(x, (3 + 4) * 5)", "baz.bar.foo(x, (3 + 4) * 5)", null }, - { "!(bar instanceof Integer)", null, null }, - { "(true ? foo : bar).baz()", null, null }, - { "((String) foo).length()", null, null }, - { "-~2", "-(~2)", "-(~2)" }, - { "(new String[1])[0]", null, null }, - { "(new String()).length()", "new String().length()", null }, - { "(new int[] { 1, 2 })[0]", "new int[] { 1, 2 }[0]", null }, - { "(\"asdf\" + \"qwer\").length()", null, null }, - { "-(a++)", "-a++", null }, - }; - - for(int i = 0; i < exprs.length; ++i) { - String input = exprs[i][0]; - String expectSimplify = exprs[i][1]; - if (expectSimplify == null) { - expectSimplify = input; - } - - String expectNoSimplify = exprs[i][2]; - if (expectNoSimplify == null) { - expectNoSimplify = input; - } - - UnparseTests.helpTestExpr(input, expectSimplify, true); - UnparseTests.helpTestExpr(input, expectNoSimplify, false); - } - } - - public void testParseUnparseParseJanino() throws Exception { - - // Process all "*.java" files in the JANINO source tree. - this.find(new File("src"), new FileFilter() { - - public boolean accept(File f) { - if (f.isDirectory()) return true; - - if (f.getName().endsWith(".java") && f.isFile()) { - - try { - - // Parse the source file once. - InputStream is = new FileInputStream(f); - CompilationUnit cu1 = new Parser(new Scanner(f.toString(), is)).parseCompilationUnit(); - is.close(); - - // Unparse the compilation unit, then parse again. - ByteArrayOutputStream baos = new ByteArrayOutputStream(); - UnparseVisitor.unparse(cu1, new OutputStreamWriter(baos)); - byte[] ba = baos.toByteArray(); - CompilationUnit cu2 = new Parser(new Scanner(f.toString(), new ByteArrayInputStream(ba))).parseCompilationUnit(); - - // Compare the two ASTs. - Java.Locatable[] elements1 = this.listSyntaxElements(cu1); - Java.Locatable[] elements2 = this.listSyntaxElements(cu2); - for (int i = 0;; ++i) { - if (i == elements1.length) { - if (i == elements2.length) break; - Assert.fail("Extra element " + elements2[i]); - } - Locatable locatable1 = elements1[i]; - - if (i == elements2.length) { - Assert.fail("Element missing: " + locatable1); - } - Locatable locatable2 = elements2[i]; - - String s1 = locatable1.toString(); - String s2 = locatable2.toString(); - if (!s1.equals(s2)) { -// String s = new String(ba); - Assert.fail(locatable1.getLocation().toString() + ": Expected \"" + s1 + "\", was \"" + s2 + "\""); - } - } - } catch (Exception e) { - throw new RuntimeException(e); - } - } - return false; - } - - /** - * Traverse the given {@link CompilationUnit} and collect a list of all its - * syntactical elements. - */ - private Locatable[] listSyntaxElements(CompilationUnit cu) { - final List locatables = new ArrayList(); - new Traverser() { - - // Two implementations of "Locatable": "Located" and "AbstractTypeDeclaration". - - public void traverseLocated(Located l) { - locatables.add(l); - super.traverseLocated(l); - } - public void traverseAbstractTypeDeclaration(AbstractTypeDeclaration atd) { - locatables.add(atd); - super.traverseAbstractTypeDeclaration(atd); - } - }.traverseCompilationUnit(cu); - return (Locatable[]) locatables.toArray(new Java.Locatable[locatables.size()]); - } - }); - } - - /** - * Invoke fileFilter for all files and subdirectories in the given - * directory. If {@link FileFilter#accept(File)} returns true, - * recurse with that file/directory. - */ - private void find(File directory, FileFilter fileFilter) { - File[] subDirectories = directory.listFiles(fileFilter); - if (subDirectories == null) Assert.fail(directory + " is not a directory"); - for (int i = 0; i < subDirectories.length; ++i) this.find(subDirectories[i], fileFilter); - } -} + +/* + * Janino - An embedded Java[TM] compiler + * + * Copyright (c) 2001-2007, Arno Unkrig + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials + * provided with the distribution. + * 3. The name of the author may not be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileFilter; +import java.io.FileInputStream; +import java.io.InputStream; +import java.io.OutputStreamWriter; +import java.io.StringReader; +import java.io.StringWriter; +import java.util.ArrayList; +import java.util.List; +import junit.framework.Assert; +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +import org.codehaus.janino.Java; +import org.codehaus.janino.Parser; +import org.codehaus.janino.Scanner; +import org.codehaus.janino.UnparseVisitor; +import org.codehaus.janino.Visitor; +import org.codehaus.janino.Java.AbstractTypeDeclaration; +import org.codehaus.janino.Java.AmbiguousName; +import org.codehaus.janino.Java.ArrayAccessExpression; +import org.codehaus.janino.Java.ArrayLength; +import org.codehaus.janino.Java.Assignment; +import org.codehaus.janino.Java.Atom; +import org.codehaus.janino.Java.BinaryOperation; +import org.codehaus.janino.Java.Cast; +import org.codehaus.janino.Java.ClassLiteral; +import org.codehaus.janino.Java.CompilationUnit; +import org.codehaus.janino.Java.ConditionalExpression; +import org.codehaus.janino.Java.ConstantValue; +import org.codehaus.janino.Java.Crement; +import org.codehaus.janino.Java.FieldAccess; +import org.codehaus.janino.Java.FieldAccessExpression; +import org.codehaus.janino.Java.Instanceof; +import org.codehaus.janino.Java.Literal; +import org.codehaus.janino.Java.LocalVariableAccess; +import org.codehaus.janino.Java.Locatable; +import org.codehaus.janino.Java.Located; +import org.codehaus.janino.Java.MethodInvocation; +import org.codehaus.janino.Java.NewAnonymousClassInstance; +import org.codehaus.janino.Java.NewArray; +import org.codehaus.janino.Java.NewClassInstance; +import org.codehaus.janino.Java.NewInitializedArray; +import org.codehaus.janino.Java.ParameterAccess; +import org.codehaus.janino.Java.ParenthesizedExpression; +import org.codehaus.janino.Java.QualifiedThisReference; +import org.codehaus.janino.Java.SuperclassFieldAccessExpression; +import org.codehaus.janino.Java.SuperclassMethodInvocation; +import org.codehaus.janino.Java.ThisReference; +import org.codehaus.janino.Java.UnaryOperation; +import org.codehaus.janino.util.Traverser; + +public class UnparseTests extends TestCase { + public static Test suite() { + TestSuite s = new TestSuite(UnparseTests.class.getName()); + s.addTest(new UnparseTests("testSimple")); + s.addTest(new UnparseTests("testParens")); + s.addTest(new UnparseTests("testMany")); + s.addTest(new UnparseTests("testDirectAst")); + s.addTest(new UnparseTests("testParseUnparseParseJanino")); + return s; + } + + public UnparseTests(String name) { super(name); } + + private static void helpTestExpr(String input, String expect, boolean simplify) throws Exception { + Parser p = new Parser(new Scanner(null, new StringReader(input))); + Atom expr = p.parseExpression(); + if (simplify) { + expr = UnparseTests.stripUnnecessaryParenExprs(expr); + } + + StringWriter sw = new StringWriter(); + UnparseVisitor uv = new UnparseVisitor(sw); + expr.accept(uv); + String s = sw.toString(); + s = UnparseTests.replace(s, "((( ", "("); + s = UnparseTests.replace(s, " )))", ")"); + Assert.assertEquals(expect, s); + } + private static String replace(String s, String from, String to) { + for (;;) { + int idx = s.indexOf(from); + if (idx == -1) break; + s = s.substring(0, idx) + to + s.substring(idx + from.length()); + } + return s; + } + + private static Java.Rvalue[] stripUnnecessaryParenExprs(Java.Rvalue[] rvalues) { + Java.Rvalue[] res = new Java.Rvalue[rvalues.length]; + for(int i = 0; i < res.length; ++i) { + res[i] = UnparseTests.stripUnnecessaryParenExprs(rvalues[i]); + } + return res; + } + + private static Java.Atom stripUnnecessaryParenExprs(Java.Atom atom) { + if (atom instanceof Java.Rvalue) { + return UnparseTests.stripUnnecessaryParenExprs((Java.Rvalue)atom); + } + return atom; + } + + private static Java.Lvalue stripUnnecessaryParenExprs(Java.Lvalue lvalue) { + return (Java.Lvalue)UnparseTests.stripUnnecessaryParenExprs((Java.Rvalue)lvalue); + } + + private static Java.Rvalue stripUnnecessaryParenExprs(Java.Rvalue rvalue) { + if (rvalue == null) { return null; } + final Java.Rvalue[] res = new Java.Rvalue[1]; + Visitor.RvalueVisitor rv = new Visitor.RvalueVisitor() { + public void visitArrayLength(ArrayLength al) { + res[0] = new Java.ArrayLength( + al.getLocation(), + UnparseTests.stripUnnecessaryParenExprs(al.lhs) + ); + } + + public void visitAssignment(Assignment a) { + res[0] = new Java.Assignment( + a.getLocation(), + UnparseTests.stripUnnecessaryParenExprs(a.lhs), + a.operator, + UnparseTests.stripUnnecessaryParenExprs(a.rhs) + ); + } + + public void visitBinaryOperation(BinaryOperation bo) { + res[0] = new Java.BinaryOperation( + bo.getLocation(), + UnparseTests.stripUnnecessaryParenExprs(bo.lhs), + bo.op, + UnparseTests.stripUnnecessaryParenExprs(bo.rhs) + ); + } + + public void visitCast(Cast c) { + res[0] = new Java.Cast( + c.getLocation(), + c.targetType, + UnparseTests.stripUnnecessaryParenExprs(c.value) + ); + } + + public void visitClassLiteral(ClassLiteral cl) { + res[0] = cl; //too much effort + } + + public void visitConditionalExpression(ConditionalExpression ce) { + res[0] = new Java.ConditionalExpression( + ce.getLocation(), + UnparseTests.stripUnnecessaryParenExprs(ce.lhs), + UnparseTests.stripUnnecessaryParenExprs(ce.mhs), + UnparseTests.stripUnnecessaryParenExprs(ce.rhs) + ); + } + + public void visitConstantValue(ConstantValue cv) { + res[0] = cv; + } + + public void visitCrement(Crement c) { + if (c.pre) { + res[0] = new Java.Crement( + c.getLocation(), + c.operator, + UnparseTests.stripUnnecessaryParenExprs(c.operand) + ); + } else { + res[0] = new Java.Crement( + c.getLocation(), + UnparseTests.stripUnnecessaryParenExprs(c.operand), + c.operator + ); + } + } + + public void visitInstanceof(Instanceof io) { + res[0] = new Java.Instanceof( + io.getLocation(), + UnparseTests.stripUnnecessaryParenExprs(io.lhs), + io.rhs + ); + } + + public void visitLiteral(Literal l) { + res[0] = l; + } + + public void visitMethodInvocation(MethodInvocation mi) { + res[0] = new Java.MethodInvocation( + mi.getLocation(), + UnparseTests.stripUnnecessaryParenExprs(mi.optionalTarget), + mi.methodName, + UnparseTests.stripUnnecessaryParenExprs(mi.arguments) + ); + } + + public void visitNewAnonymousClassInstance(NewAnonymousClassInstance naci) { + res[0] = naci; //too much effort + } + + public void visitNewArray(NewArray na) { + res[0] = new Java.NewArray( + na.getLocation(), + na.type, + UnparseTests.stripUnnecessaryParenExprs(na.dimExprs), + na.dims + ); + } + + public void visitNewClassInstance(NewClassInstance nci) { + res[0] = new Java.NewClassInstance( + nci.getLocation(), + UnparseTests.stripUnnecessaryParenExprs(nci.optionalQualification), + nci.type, + UnparseTests.stripUnnecessaryParenExprs(nci.arguments) + ); + } + + public void visitNewInitializedArray(NewInitializedArray nia) { + res[0] = nia; //too much effort + } + + public void visitParameterAccess(ParameterAccess pa) { + res[0] = pa; + } + + public void visitQualifiedThisReference(QualifiedThisReference qtr) { + res[0] = qtr; + } + + public void visitSuperclassMethodInvocation(SuperclassMethodInvocation smi) { + res[0] = new Java.SuperclassMethodInvocation( + smi.getLocation(), + smi.methodName, + UnparseTests.stripUnnecessaryParenExprs(smi.arguments) + ); + } + + public void visitThisReference(ThisReference tr) { + res[0] = tr; + } + + public void visitUnaryOperation(UnaryOperation uo) { + res[0] = new Java.UnaryOperation( + uo.getLocation(), + uo.operator, + UnparseTests.stripUnnecessaryParenExprs(uo.operand) + ); + } + + public void visitAmbiguousName(AmbiguousName an) { + res[0] = an; + } + + public void visitArrayAccessExpression(ArrayAccessExpression aae) { + res[0] = new Java.ArrayAccessExpression( + aae.getLocation(), + UnparseTests.stripUnnecessaryParenExprs(aae.lhs), + UnparseTests.stripUnnecessaryParenExprs(aae.index) + ); + } + + public void visitFieldAccess(FieldAccess fa) { + res[0] = new Java.FieldAccess( + fa.getLocation(), + UnparseTests.stripUnnecessaryParenExprs(fa.lhs), + fa.field + ); + } + + public void visitFieldAccessExpression(FieldAccessExpression fae) { + res[0] = new Java.FieldAccessExpression( + fae.getLocation(), + UnparseTests.stripUnnecessaryParenExprs(fae.lhs), + fae.fieldName + ); + } + + public void visitLocalVariableAccess(LocalVariableAccess lva) { + res[0] = lva; + } + + public void visitParenthesizedExpression(ParenthesizedExpression pe) { + res[0] = UnparseTests.stripUnnecessaryParenExprs(pe.value); + } + + public void visitSuperclassFieldAccessExpression(SuperclassFieldAccessExpression scfae) { + res[0] = scfae; + } + + }; + rvalue.accept(rv); + return res[0]; + } + + public void testSimple() throws Exception { + UnparseTests.helpTestExpr("1 + 2*3", "1 + 2 * 3", false); + UnparseTests.helpTestExpr("1 + 2*3", "1 + 2 * 3", true); + } + + public void testParens() throws Exception { + UnparseTests.helpTestExpr("(1 + 2)*3", "(1 + 2) * 3", false); + UnparseTests.helpTestExpr("(1 + 2)*3", "(1 + 2) * 3", true); + } + + public void testMany() throws Exception { + final String[][] exprs = new String[][] { + //input expected simplified expect non-simplified + { "((1)+2)", "1 + 2", "((1) + 2)" }, + { "1 - 2 + 3", null, null }, + { "(1 - 2) + 3", "1 - 2 + 3", null }, + { "1 - (2 + 3)", "1 - (2 + 3)", null }, + { "1 + 2 * 3", null, null }, + { "1 + (2 * 3)", "1 + 2 * 3", null }, + { "3 - (2 - 1)", null, null }, + { "true ? 1 : 2", null, null }, + { "(true ? false : true) ? 1 : 2", null, null }, + { "true ? false : (true ? false : true)", "true ? false : true ? false : true", null }, + { "-(-(2))", "-(-2)", "-(-(2))" }, + { "- - 2", "-(-2)", "-(-2)" }, + { "x && (y || z)", null, null }, + { "(x && y) || z", "x && y || z", null }, + { "x = (y = z)", "x = y = z", null }, + { "x *= (y *= z)", "x *= y *= z", null }, + { "(--x) + 3", "--x + 3", null }, + { "(baz.bar).foo(x, (3 + 4) * 5)", "baz.bar.foo(x, (3 + 4) * 5)", null }, + { "!(bar instanceof Integer)", null, null }, + { "(true ? foo : bar).baz()", null, null }, + { "((String) foo).length()", null, null }, + { "-~2", "-(~2)", "-(~2)" }, + { "(new String[1])[0]", null, null }, + { "(new String()).length()", "new String().length()", null }, + { "(new int[] { 1, 2 })[0]", "new int[] { 1, 2 }[0]", null }, + { "(\"asdf\" + \"qwer\").length()", null, null }, + { "-(a++)", "-a++", null }, + { "-1", null, null }, + }; + + for(int i = 0; i < exprs.length; ++i) { + String input = exprs[i][0]; + String expectSimplify = exprs[i][1]; + if (expectSimplify == null) { + expectSimplify = input; + } + + String expectNoSimplify = exprs[i][2]; + if (expectNoSimplify == null) { + expectNoSimplify = input; + } + + UnparseTests.helpTestExpr(input, expectSimplify, true); + UnparseTests.helpTestExpr(input, expectNoSimplify, false); + } + } + + public void testDirectAst() throws Exception { + Object[][] tests = new Object[][] { + { Integer.valueOf(-1), "-1" }, + { Integer.valueOf(0xE0000000), "-536870912" }, + }; + + for(int i = 0; i < tests.length; ++i) { + StringWriter sw = new StringWriter(); + UnparseVisitor uv = new UnparseVisitor(sw); + Java.Literal lit = new Java.Literal(null, tests[i][0]); + lit.accept(uv); + Assert.assertEquals((String)tests[i][1], sw.toString()); + } + } + + public void testParseUnparseParseJanino() throws Exception { + + // Process all "*.java" files in the JANINO source tree. + this.find(new File("src"), new FileFilter() { + + public boolean accept(File f) { + if (f.isDirectory()) return true; + + if (f.getName().endsWith(".java") && f.isFile()) { + + try { + + // Parse the source file once. + InputStream is = new FileInputStream(f); + CompilationUnit cu1 = new Parser(new Scanner(f.toString(), is)).parseCompilationUnit(); + is.close(); + + // Unparse the compilation unit, then parse again. + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + UnparseVisitor.unparse(cu1, new OutputStreamWriter(baos)); + byte[] ba = baos.toByteArray(); + CompilationUnit cu2 = new Parser(new Scanner(f.toString(), new ByteArrayInputStream(ba))).parseCompilationUnit(); + + // Compare the two ASTs. + Java.Locatable[] elements1 = this.listSyntaxElements(cu1); + Java.Locatable[] elements2 = this.listSyntaxElements(cu2); + for (int i = 0;; ++i) { + if (i == elements1.length) { + if (i == elements2.length) break; + Assert.fail("Extra element " + elements2[i]); + } + Locatable locatable1 = elements1[i]; + + if (i == elements2.length) { + Assert.fail("Element missing: " + locatable1); + } + Locatable locatable2 = elements2[i]; + + String s1 = locatable1.toString(); + String s2 = locatable2.toString(); + if (!s1.equals(s2)) { + Assert.fail(locatable1.getLocation().toString() + ": Expected \"" + s1 + "\", was \"" + s2 + "\""); + } + } + } catch (Exception e) { + throw new RuntimeException(e); + } + } + return false; + } + + /** + * Traverse the given {@link CompilationUnit} and collect a list of all its + * syntactical elements. + */ + private Locatable[] listSyntaxElements(CompilationUnit cu) { + final List locatables = new ArrayList(); + new Traverser() { + + // Two implementations of "Locatable": "Located" and "AbstractTypeDeclaration". + public void traverseLocated(Located l) { + Object last = locatables.isEmpty() ? null : locatables.get(locatables.size() - 1); + // -1 is often parsed as [Op(-, Lit(1))], so we bring them back together + if(l instanceof Java.UnaryOperation && + last instanceof Java.Literal && + ((Java.UnaryOperation)l).operator.equals("-") && + ((Java.Literal)last).value instanceof Number) { + Number n = (Number)((Java.Literal)last).value; + Object res = n; + if(n instanceof Byte) { res = Byte .valueOf((byte) -n.byteValue()); } + if(n instanceof Short) { res = Short .valueOf((short)-n.shortValue()); } + if(n instanceof Integer) { res = Integer.valueOf(-n.intValue()); } + if(n instanceof Long) { res = Long .valueOf(-n.longValue()); } + if(n instanceof Float) { res = Float .valueOf(-n.floatValue()); } + if(n instanceof Double) { res = Double .valueOf(-n.doubleValue()); } + locatables.set(locatables.size()-1, + new Java.Literal(l.getLocation(), res)); + } else { + locatables.add(l); + } + super.traverseLocated(l); + } + public void traverseAbstractTypeDeclaration(AbstractTypeDeclaration atd) { + locatables.add(atd); + super.traverseAbstractTypeDeclaration(atd); + } + }.traverseCompilationUnit(cu); + return (Locatable[]) locatables.toArray(new Java.Locatable[locatables.size()]); + } + }); + } + + /** + * Invoke fileFilter for all files and subdirectories in the given + * directory. If {@link FileFilter#accept(File)} returns true, + * recurse with that file/directory. + */ + private void find(File directory, FileFilter fileFilter) { + File[] subDirectories = directory.listFiles(fileFilter); + if (subDirectories == null) Assert.fail(directory + " is not a directory"); + for (int i = 0; i < subDirectories.length; ++i) this.find(subDirectories[i], fileFilter); + } +} === src/org/codehaus/janino/Scanner.java ================================================================== --- src/org/codehaus/janino/Scanner.java (revision 72702) +++ src/org/codehaus/janino/Scanner.java (patch unparse-fix level 1) @@ -442,13 +442,11 @@ } if (v instanceof Integer) { if (v == Scanner.MAGIC_INTEGER) return "2147483648"; - int iv = ((Integer) v).intValue(); - return iv < 0 ? Integer.toHexString(iv) : Integer.toString(iv); + return v.toString(); } if (v instanceof Long) { if (v == Scanner.MAGIC_LONG) return "9223372036854775808L"; - long lv = ((Long) v).longValue(); - return (lv < 0L ? Long.toHexString(lv) : Long.toString(lv)) + 'L'; + return v.toString() + "L"; } if (v instanceof Float) { return v.toString() + 'F'; ==== BEGIN SVK PATCH BLOCK ==== Version: svk v2.0.2 (linux) eJy9XE+M41hatxCn4rASQkJCSDxqamec7iSVOFWVStVMT6erUt2ZrUpqk1T3tJpWj2M/V3nasTO2 k1RNp5ikd6TRAjtCXFYrDivYPQASHLlx5AAHbly4IAEHBMPfBZZ/C3zf85/YjuM4UyWsma7Y7/t+ 35/3vfe+98c+Mjv794vje/cK441iYdx+/LW9vVPRli6+CncbO2Mqq7ZhbmyPNTqk2kZprBnnG1tj XexRKLVF85za9+4VgXnXYa4xBg9kCzG6om3o1kaFgb2wTUo3iuPKfRBwv4T/vdgoVsYWhSIG98Kk Q9VSDR2klre2hQKQAEMRAIw+1V+YhmFjkVAuVO4LyF0YS5ph0ReIj5DbSC9sFLccBlk1qQRKXQGX TS3bYmgeAiPejiEujS1TCpEyVbddYTNCIAE9HKBSDFDFkbrpwAnL4QQfbsszWlE1uiGUZ0ibZ3pf NC3awQf5D8WhyKQvxS452KxU7Pe1qxc2vbRlqtkik1cSxnJZ2JIoLQi73VKpRMvbJbpTFul2t7Cj iAVpB+p6q1iE6m5w3PS370x///3X69NvVSYWd/Tx5JsK9/CX35l8+0Puwfc+mfxSnjv9vV+cfOs+ V/uD/clnb3C1P3x38o0s994f3ftN7ukf5yevNe7oT7jJZz/Dfe1Pryaf/ix3+mf25NM3uNM/H02m H3LHf1H5Xa79lzuTZ5zyVxeT1x9xR3+9N5kWOPtvBG70t29xoy9+jhv93U9zo7//yre5D77Y4Ub/ 8Ak3+scRN/ongxv98zk3+sELbvQvT7jRvza/y73/xT1u9MN3udG/l7nRf2xyo/8EhP8ChP8GhB99 5Xe4kx9VuNH/fPIr3Oh/AWI6AYzpFECmrwFl+o0nv879whd7k89PuNb0c30y/Qluujb91cbkszo3 /fHpd6zJpwInT7+7P/n8KffB9Hv93+A60+9/Mnnd5brT33r7m2ubd9bIHfKeqKu6QXKkqhPa61JZ pjI8HIrPOifPiWT0+lDZJlAi8YHRvzLV8wub8FKGCIVCMQf/lLOkagLGmf4SCpGuqmmE0VnEpBY1 h1TOuxA9Q1YVVRJtaFNZIpqU9KnZU20bxPZNY6iifPtCtOEfShRD04yRqp+DJjo0KGCyEAX5etTe c0HhKuZJC5qcZZtqd8DoiKEQyxiYEgVmGegHlg3q2KKqM2yxawyxyDXJxYFLN2xVolkgUi2iASQi zeQTUZcjyoFcSRPVHjXzLowwrw6I7aq6aF4Bo9nz1AGb5QGo6Gs008NXbXWNZiAz1Yhrt2xIgx7V bVYFyLppmMSAEpP0RJuaqqhZM36/TkaqfeHwB6zyzC3lSQeKsCdG1ZgxA/vCQMgrVJ90KRlYWLUG obpsQGdBoBTQe4ZNQ+LAHRA3MigCYUMUoHDstgzFHmHFoybGwCZWn0oYS8CkGuYMY2RiOOlOYFmW qyaWdx7V26TdPOo8qbZqBH6ftpqP64e1Q/LgKRTWSPWs86jZIh98UG1D8VtvkWrjEP5/Smrvn7Zq 7TZpthCnfnJ6XAcugGlVG516rZ0l9cbB8dlhvfEwSx6cdUij2SHH9ZN6B8g6zSxDd9kQYcZJmkfk pNY6eAS31Qf143rnKZN6VO80UOIR6FMlp9VWp35wdlxtkdOz1mmzXWPtDKw4rLcPjqv1k9phHnQA uaT2uNbokPaj6vFx0KgHNVCo+uC45kA2niLCYb1VO+ig9rNfB+AR0OU4S9qntYM6/qi9XwPdq62n WfAAOWg22rWvnwERFDKU6kn1IZjCL3ECuPvgrFU7Qf3A7PbZg3an3jnrMGMeNpuH6GDSrrUe1w9q 7X1y3Gwz/5y1a1kQ0qky8YACzoFiNOqsXUc3sVppdGqt1tlpp95sZMij5hNwBChbBe5D5tJmg9Ul +KTZeoq46A/m8Sx58qgGz53abaCFnVYV3dHutOoHnSAlSO00W52AsaRRe3hcf1hrHNS8ADki1cPH dRQMYrASoMradbd6mekHj1y3YXBurq2pvb5h2gQHz7xq5B9c2bRqmuJVXe8P7DYkKmJvfyFRc2Av pjqCHjz2IfwP7T22KElqUllQkSfQDmPgoRB6qBYV5YWFcZzQ32h5ZuwxdEAxZeHHA12184oJHdLI MF/mqxYMQ4uLMXFJLDwQLZpI0B6Ayvt+NRrmeR5HnQtxgAkRjrF5HFX3kwhOMYcyE0nakqjrS2jc ZOwx5K2QZyWSpqFBtfPVLnT6omR3rvr0kMKIYrLhIwVjr6ueD4yB1QBvpSDHCq5KErWs2mUfkgcr nRQWF1Q/ty9SEAPouY5DYApa2+gtp3rAxvUmDDgpvQLhlEL4gSZa1jE2BVFLQc1yNabAGcRnGgY3 gRC1VXwNbJYt6vZjURukqNEDk6Zz9ZFKNdmp+pWIV9G9zlSXqKEsp03t+GNDErXHIiROXY2mNQCZ bGRISUrl5YQnFBIjua4PDSllHDboqKob+lUPGiiLNs9B6Vix1aWiXB27DiEMmaj6MZVTioHeE7oY qLO0VQAMEJgX1EIhq0TR1wegmKJSuQN5aYsqFHDSmNUeQA8hoSu+ZPjOAFav6hV1PUvfo7HRt2OK Q+oMX2v9QVeDtJwpSoJLAwRm95D9W8QbUsmrNZb1OwwWzkkkVkgsHE/5jEuAlz/KEou8Q3Q6mj3h Q+sPTG7+nNo45PCZzL4PYeVFWUYiHtmDTPw6Lma0wUqNrq/CwoLIWonlRNSvVmI4ZEsmVcteVTOL uo/Zb2eqH8KA6fDA1InlPLleC9ZGCNHJy9gED+oEagcig2d3+8CGXA4rTNpErCGnJoeGKpMLqvUR BAPdw1ExhYTk2rmjlzCTg9uuYWhUBHWwGlTlKgMTP9MYWaR2KdE+m67OwsFJlkjfjQXnlrnCzZF4 faBpWVYYTDl5JjsT9AIO8qiECVj9PLN61ir5AKGqEH6m3EyXa/+X/yOYyBJr5GoZfBoEDqdsZDB0 6cPPeWsU4EGF86KEnuEHw0CB61VsJdYobxvOfVAcFoWajEn7mihR3sqSdZ7nyTr+XU/LQcCbyJEJ cjgZd15kf2ofQZdp8V5FWxkv4GKCxlXfE+BZ40cLrgj4N7YRrAcFfMfv7wcfsWrTbaLKl+iPvKrL 9LKp8IgS0NarXUb2DskVM6QLc5iXYQrm0rw1wGQYXVrIIm6G3MVljbuhIgS6y3TNaywvDXVE1wtb oB9EEa+wTrk1xJzr2XOCQvpnEOU4gkBHzXohjFmLDxOa7IcV9EiEgHq9afC5y+aq/nw/6GGeuROY Cvvw521EcOn2yd27atT5UPxMfR4NnwQDXNnAlOQwgE3lMta2l7mLEYnwT1B5DAd8BuHjJY1BH83b yfRKa2WwnjJMdIKxIpuFpLD2mOEttdcl0+YMceUFqTJfyiIXek5pz7FOJWNTw14ahxRXNN7uBzyg wNRKSxWzxUCYuh2mW+R1q6bXrcYW89EadcdBNojhJpAdmGXygd9E1KKsXuAXngcVDfLPkeMlapi2 HLs5HZ/JxlKlrRBA0y6szBxGpNtzR/3FVvvTZX72k4gpTZ4xx1t8qwYze+MxxLzBklnDvKkM8xZ8 Glkw4CP3kAmlc28UJ9a0rnGbTga0xV6GQqN/Y/zb8DCusPD4D5HSuZIxxGoupXGflHc2jHGB7GYO kPJO33ljDwRWj/jgDUzMEl0iQQe8uWkbBukNpAtCFRj07dVEx60s8bFPiTQ3koaUmdVPLGZ8XdDb DHhAWxzwK4DcSlQH19740B2Rhsm1OlxRlLNux7t/45sRDuVSHmojrjAkflaPLm4sOV6pmptDmNyl 45W+0TEsXZ6vIrwi1YTXNaGav4Dx/2n26ialcWFqs1cKotl6Kz/7SdSUo1uAO1Y9NdXAprIB5aYt z+tIvT40uQvVVgOPrubx0QekNzevinfZHFKsS3rqbXaQgGb0nZ65w8bABXhA12Pq4brcPElyhYTN FSX1pmOUt37Nez8ANZ2Pfc5YK/VUKS1Q2TfOFABEVnvs92IxQLFq8C80O7SMv8B86VZjC+G84HKX 3R3gRQYD/S04FlAgktkxmZsP2jG7GXzMM6KrSwJQFW8a9JE9Ej5yT/rJGvTF1SyP3yjh4x+Tj2wz UTqUryZ+8XYJv7iIWGn72gT42Oiz0nW71o36yTknhF0f9vgSh6/q7/CeER++JYOUo/5ZiintINXI PzBuadLvAcWlh6uupgTPQ/ChOyLqiR4S9S/Ra8ceqFiwFiPe6rwJ4W4+cUIUtmZ/Y88H9lz5wG+i pBz2g/yxJim3upilJK1mQaGC6tzKwB67Gb3IxFsNESUxRLCUWYmN4yaWasPkcStEnFb3Ps0H17jT QFsSmBQlD975N9eBLVomxdvoM4fzu7cO/vz+QKABzDa3+cRN1ZDxoY3b9SK5S4Q7JdznYz/JHYI3 igiz4PmdzBUQbDNuoyCqvbPP/qW155nEjCPdvVlJPm7aJ0t3diqcfclnz589Zxu03kZF4HG4r3nl OyP6+JK8+Sbhr8h4TD7OrGejxby7M5ohimFk/E1GMCg2olyuXNEniAu2mTHz+3zMnKSdvuDePrAx +mfqcz82I3TOZnDb3U4PMhQjDLjKFKX2N47mmtscLlMoVbOb065hxOknLNQvSD/b2lqgYgjcUZKk 1XJxqLtHK8JeCEX5ihgzNedb+7XbbGKbjH9sJbndNLsfAhlrGuyFIrfFBB7P1/ErUtdtek5Npw9u KnyumMmy8CbX86PJPHnhslZwLsa2XdrZLRcqRSHEnrJhMK2XN4y0Z0ECVbPSeRC8ggcXiabawWHe W8FyjsUwpZ3WGcEAtthjJXjFHerw+iEfsfg8Gz54kjZgFpxYig8fH3Jzk5yaBkvlRE0j63fYC2jr BN9Ss7yXXt6rNuqNpvc+EL72l/cB8O0SSDR0mZ0ewtPv/LplSusZ5/DQ7KQ82yGOSzK9g0uu25CD KIvWy5W8ah16L8GBc7xhHFvo/nz24LD4p9nyeH7uiQpd/bpjZwaHCcRkimfmVPStNK8WFXleRJcz b7luQg8SAyaK+YVsgXcBiOo13cgLBLwSs47sXZFTy0QaFBef6FICQZUFeZmMc1orAhJtTSF34vlA w6JIk+QMNwyZO6QZPMGj//giFr5fxAjEc1HVFzso3GLzA+eWBzOd6Jp/YYLvioaVSTChe2XjKYiu CI5CWnCK/yLIMrPQU/gOFZpljwxSbXesxcqHTypjSqOxXQwL64g1G3wZrX2l2+JlzS1C0xKUXwgp JEIKCZDs1NesT47tgqMXO+uFY7RvkduBL2OMZRZ85phDY3GX248qoqrx67VL2xQ9LLIO2aCPGz4E FXddJ5b6jiaa9wurzjca8BPiZYmtyx0VNtM1kL2Tp5/vMUtnat22nULATmG5nd4xQ3TPTKnY05NJ 7EKQXUjNjl7+eYhB6gyplpBZ5t7F/ogvuSYSvgRP+NkYunDTFi824rIeqjXQbbVHfT4+mkcuFjz/ xB3rWB6ZOHHevBOeEOHbm+4Rc9Z5natD6IJf3ddU/WV0ELlmL8RKhqbBIEtE/41ZTA9U24riWtjZ SLYqQc7kRUykT7yzGR723aN3wX4sptuaH9viPO7MG/HttVnkeCOp/75bXACxI/Desfv53MRXNphl ueTuKyW8+zd+N9O7nEycaHiYJhDdFuQctV7fxmnxu2yuQ/aCpZCy8IFbfMsCKHMkqaXDCJUrYiJh KLY3wspEtMizZp/PZcFLNl/MZDDBNMiIQnfLDgFf0B6MhNJLYhsg9YLG72bjpSq8NnegM7JQ/eab Szs25osojJd3p+B3D0uGBWe0jL9e7fUE6zmW4KUFdFXIoH4ZZ7ITVLMx6HVp7Jp/8HKoiA6Vzbsc i+GT+zU3dNwDm8v6QF4PKos5TQYLXrn8+ABu/Tkc32UUOT2PP5wjMZA3LRsronLaF4ZpZwJy2IOg HItRgBz2YyZoNTnuFDTjy5mbwup5VQ/A+9f1/ApCkqBjA1eFAgbhg6DjQJAGj+YlrSjoSDPEkOfY g7AgBR/NSVpR0KEBfRgGgyfIeRASJLNHUUlLBAX7p7juKgdZ+tK2h9fcLDt6khcVT0rqE48TRVQV ZZnXkrAWlrD3dvLRUWARVjxO3Hiy4PVgfsFzItpyUi8UsRWpF1sbtmmRJmGMmFTFR4hOJmHUDq4O s1/+E/bHz1XukLfx5bh7/jdu3t5k93lSV7xcZbac8EZguSBz7aZGlguBqwEud9YDB9AB5j/upzig qeEMfdOX5iYtbrLiJSmsotjyBluX8KmzAVUYkPMzWC9IgG+bDLregoXKmt9MImY9SGXxAYSZn9kL UxFub100ODnwAWFKsI7jP34yRJzJWfcdfr12fyv4mSX2LSL3W0GSvLUrVHa6wi7t0rJYEsq7O9vb FarQHVqqKAX/S0Y7MR9GKuMXljYN85x9gWnpp4u2fbByDFhxx0Pb9N6WZGKXwu74sLsxsEJpDnbT eQmT6bEUveyjV0LfcirNq+vibrpLL95HnXaXC9lN/KhTBStKpFKhUlLoblkobNGdrUpxt7JLK9KO TIuFXUXYKO84X3R6/cMPX//b3k/d5abTV9yvcdMfm74+/w43/cFPTj99351KDGeTrPkn+GrW+vF6 bMgwTZRtulPplpWKotDujlgsKXKhK1O5VNmtlHYrW+yTW0WhPCam8/kvq69KdERFi2qEh4g+hwL0 R2YPFyJGmLqP8ctIu7nCdk4okWJxT9jdEwSSK2wVCmvQpC5hdgIhbg3o7Js6FzBh0TCVhcFOp+fQ +bBPEznHe2HCsrZRLI7dtaOcol7euyeMNwTB+cqZc+hubw96K+zARO2rO+ONrXFftC82SmOTDuFm MFDlDaEy3oS5+6Z9oZpyDsDsK6+aobvRX7p1K2A8lEtlBWpCylXgb65QKhZyolTp5iRFlHYlqSgK yvb/AXUZfcw= ==== END SVK PATCH BLOCK ====