Index: src/contrib/hbase/src/java/org/apache/hadoop/hbase/Shell.java =================================================================== --- src/contrib/hbase/src/java/org/apache/hadoop/hbase/Shell.java (revision 575307) +++ src/contrib/hbase/src/java/org/apache/hadoop/hbase/Shell.java (working copy) @@ -68,9 +68,10 @@ } } catch (ParseException pe) { String[] msg = pe.getMessage().split("[\n]"); - System.out.println("Syntax error : Type 'help' for usage: " + msg[0]); + System.out.println("Syntax error : Type 'help' for usage.\nMessage : " + msg[0]); } catch (TokenMgrError te) { - System.out.println("Lexical error : Type 'help' for usage."); + String[] msg = te.getMessage().split("[\n]"); + System.out.println("Lexical error : Type 'help' for usage.\nMessage : " + msg[0]); } long end = System.currentTimeMillis(); Index: src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/HelpContents.java =================================================================== --- src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/HelpContents.java (revision 575307) +++ src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/HelpContents.java (working copy) @@ -37,9 +37,12 @@ load.put("SHOW", new String[] {"List all available tables", "SHOW TABLES;"}); - load.put("FS", new String[] { "Hadoop FsShell operations.", + load.put("FS", new String[] { "Hadoop FsShell operations", "FS -copyFromLocal /home/user/backup.dat fs/user/backup;" }); + load.put("JAR", new String[] { "Hadoop RunJar util", + "JAR ./build/hadoop-examples.jar pi 10 10;" }); + load.put("CLEAR", new String[] {"Clear the screen", "CLEAR;"} ); load.put("DESCRIBE", new String[] { "Print information about tables", Index: src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/JarCommand.java =================================================================== --- src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/JarCommand.java (revision 0) +++ src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/JarCommand.java (revision 0) @@ -0,0 +1,147 @@ +/** + * Copyright 2007 The Apache Software Foundation + * + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hbase.shell; + +import java.io.File; +import java.io.IOException; +import java.lang.reflect.Array; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.jar.JarFile; +import java.util.jar.Manifest; + +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.fs.FileUtil; +import org.apache.hadoop.util.RunJar; + +/** + * Run hadoop jar commands. + */ +public class JarCommand extends BasicCommand { + + private List query; + + @SuppressWarnings("deprecation") + public ReturnMsg execute(@SuppressWarnings("unused") Configuration conf) { + + try { + String[] args = getQuery(); + String usage = "JAR jarFile [mainClass] args...;\n"; + + if (args.length < 1) { + return new ReturnMsg(0, usage); + } + + int firstArg = 0; + String fileName = args[firstArg++]; + File file = new File(fileName); + String mainClassName = null; + + JarFile jarFile; + try { + jarFile = new JarFile(fileName); + } catch(IOException io) { + throw new IOException("Error opening job jar: " + fileName + "\n") + .initCause(io); + } + + Manifest manifest = jarFile.getManifest(); + if (manifest != null) { + mainClassName = manifest.getMainAttributes().getValue("Main-Class"); + } + jarFile.close(); + + if (mainClassName == null) { + if (args.length < 2) { + return new ReturnMsg(0, usage); + } + mainClassName = args[firstArg++]; + } + mainClassName = mainClassName.replaceAll("/", "."); + + File tmpDir = new File(new Configuration().get("hadoop.tmp.dir")); + tmpDir.mkdirs(); + if (!tmpDir.isDirectory()) { + return new ReturnMsg(0, "Mkdirs failed to create " + tmpDir + "\n"); + } + final File workDir = File.createTempFile("hadoop-unjar", "", tmpDir); + workDir.delete(); + workDir.mkdirs(); + if (!workDir.isDirectory()) { + return new ReturnMsg(0, "Mkdirs failed to create " + workDir + "\n"); + } + + Runtime.getRuntime().addShutdownHook(new Thread() { + public void run() { + try { + FileUtil.fullyDelete(workDir); + } catch (IOException e) { + } + } + }); + + RunJar.unJar(file, workDir); + + ArrayList classPath = new ArrayList(); + classPath.add(new File(workDir+"/").toURL()); + classPath.add(file.toURL()); + classPath.add(new File(workDir, "classes/").toURL()); + File[] libs = new File(workDir, "lib").listFiles(); + if (libs != null) { + for (int i = 0; i < libs.length; i++) { + classPath.add(libs[i].toURL()); + } + } + ClassLoader loader = + new URLClassLoader(classPath.toArray(new URL[0])); + + Thread.currentThread().setContextClassLoader(loader); + Class mainClass = Class.forName(mainClassName, true, loader); + Method main = mainClass.getMethod("main", new Class[] { + Array.newInstance(String.class, 0).getClass() + }); + String[] newArgs = (String[])Arrays.asList(args) + .subList(firstArg, args.length).toArray(new String[0]); + try { + main.invoke(null, new Object[] { newArgs }); + } catch (InvocationTargetException e) { + throw e.getTargetException(); + } + + } catch (Throwable e) { + e.printStackTrace(); + } + + return null; + } + + public void setQuery(List query) { + this.query = query; + } + + private String[] getQuery() { + return query.toArray(new String[] {}); + } +} Index: src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/ParserTokenManager.java =================================================================== --- src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/ParserTokenManager.java (revision 575916) +++ src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/ParserTokenManager.java (working copy) @@ -37,193 +37,193 @@ switch (pos) { case 0: - if ((active0 & 0x400000000L) != 0L) + if ((active0 & 0x800000000L) != 0L) return 31; - if ((active0 & 0x7fff01ffffffe0L) != 0L) + if ((active0 & 0xfffe03ffffffe0L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; return 0; } return -1; case 1: - if ((active0 & 0x100002000L) != 0L) + if ((active0 & 0x200002000L) != 0L) return 0; - if ((active0 & 0x7fff00ffffdfe0L) != 0L) + if ((active0 & 0xfffe01ffffdfe0L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 1; return 0; } return -1; case 2: - if ((active0 & 0x20000082000000L) != 0L) + if ((active0 & 0x40000104004000L) != 0L) return 0; - if ((active0 & 0x5fff007dffdfe0L) != 0L) + if ((active0 & 0xbffe00fbff9fe0L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 2; return 0; } return -1; case 3: - if ((active0 & 0x80001015720L) != 0L) + if ((active0 & 0x100002029720L) != 0L) return 0; - if ((active0 & 0x5ff7007cfe88c0L) != 0L) + if ((active0 & 0xbfee00f9fd08c0L) != 0L) { if (jjmatchedPos != 3) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 3; } return 0; } return -1; case 4: - if ((active0 & 0x1000408200c0L) != 0L) + if ((active0 & 0x2000810400c0L) != 0L) return 0; - if ((active0 & 0x5fe7003c7c8a00L) != 0L) + if ((active0 & 0xbfce0078f90a00L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 4; return 0; } return -1; case 5: - if ((active0 & 0x402000041c8800L) != 0L) + if ((active0 & 0x80400008390800L) != 0L) return 0; - if ((active0 & 0x1fc70038600200L) != 0L) + if ((active0 & 0x3f8e0070c00200L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 5; return 0; } return -1; case 6: - if ((active0 & 0x200000L) != 0L) + if ((active0 & 0x400000L) != 0L) return 0; - if ((active0 & 0x1fc70038400200L) != 0L) + if ((active0 & 0x3f8e0070800200L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 6; return 0; } return -1; case 7: - if ((active0 & 0x8000000400200L) != 0L) + if ((active0 & 0x10000000800200L) != 0L) return 0; - if ((active0 & 0x17c70038000000L) != 0L) + if ((active0 & 0x2f8e0070000000L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 7; return 0; } return -1; case 8: - if ((active0 & 0x400010000000L) != 0L) + if ((active0 & 0x800020000000L) != 0L) return 0; - if ((active0 & 0x17870028000000L) != 0L) + if ((active0 & 0x2f0e0050000000L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 8; return 0; } return -1; case 9: - if ((active0 & 0x20000000000L) != 0L) + if ((active0 & 0x40000000000L) != 0L) return 0; - if ((active0 & 0x17850028000000L) != 0L) + if ((active0 & 0x2f0a0050000000L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 9; return 0; } return -1; case 10: - if ((active0 & 0x14840000000000L) != 0L) + if ((active0 & 0x29080000000000L) != 0L) return 0; - if ((active0 & 0x3010028000000L) != 0L) + if ((active0 & 0x6020050000000L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 10; return 0; } return -1; case 11: - if ((active0 & 0x10020000000L) != 0L) + if ((active0 & 0x20040000000L) != 0L) return 0; - if ((active0 & 0x3000008000000L) != 0L) + if ((active0 & 0x6000010000000L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 11; return 0; } return -1; case 12: - if ((active0 & 0x3000008000000L) != 0L) + if ((active0 & 0x6000010000000L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 12; return 0; } return -1; case 13: - if ((active0 & 0x8000000L) != 0L) + if ((active0 & 0x10000000L) != 0L) return 0; - if ((active0 & 0x3000000000000L) != 0L) + if ((active0 & 0x6000000000000L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 13; return 0; } return -1; case 14: - if ((active0 & 0x3000000000000L) != 0L) + if ((active0 & 0x6000000000000L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 14; return 0; } return -1; case 15: - if ((active0 & 0x3000000000000L) != 0L) + if ((active0 & 0x6000000000000L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 15; return 0; } return -1; case 16: - if ((active0 & 0x3000000000000L) != 0L) + if ((active0 & 0x6000000000000L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 16; return 0; } return -1; case 17: - if ((active0 & 0x3000000000000L) != 0L) + if ((active0 & 0x6000000000000L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 17; return 0; } return -1; case 18: - if ((active0 & 0x3000000000000L) != 0L) + if ((active0 & 0x6000000000000L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 18; return 0; } return -1; case 19: - if ((active0 & 0x2000000000000L) != 0L) + if ((active0 & 0x4000000000000L) != 0L) { - jjmatchedKind = 55; + jjmatchedKind = 56; jjmatchedPos = 19; return 0; } - if ((active0 & 0x1000000000000L) != 0L) + if ((active0 & 0x2000000000000L) != 0L) return 0; return -1; default : @@ -253,72 +253,75 @@ switch(curChar) { case 40: - return jjStopAtPos(0, 35); + return jjStopAtPos(0, 36); case 41: - return jjStopAtPos(0, 36); + return jjStopAtPos(0, 37); case 42: - return jjStopAtPos(0, 39); + return jjStopAtPos(0, 40); case 44: - return jjStopAtPos(0, 33); + return jjStopAtPos(0, 34); case 46: - return jjStartNfaWithStates_0(0, 34, 31); + return jjStartNfaWithStates_0(0, 35, 31); case 59: - return jjStopAtPos(0, 61); + return jjStopAtPos(0, 62); case 60: - return jjMoveStringLiteralDfa1_0(0x4000000000L); + return jjMoveStringLiteralDfa1_0(0x8000000000L); case 61: - return jjStopAtPos(0, 37); + return jjStopAtPos(0, 38); case 65: case 97: - return jjMoveStringLiteralDfa1_0(0x20000080000040L); + return jjMoveStringLiteralDfa1_0(0x40000100000040L); case 66: case 98: - return jjMoveStringLiteralDfa1_0(0x900000000000L); + return jjMoveStringLiteralDfa1_0(0x1200000000000L); case 67: case 99: - return jjMoveStringLiteralDfa1_0(0x41040008000880L); + return jjMoveStringLiteralDfa1_0(0x82080010000880L); case 68: case 100: - return jjMoveStringLiteralDfa1_0(0x241600L); + return jjMoveStringLiteralDfa1_0(0x481600L); case 69: case 101: - return jjMoveStringLiteralDfa1_0(0x104000L); + return jjMoveStringLiteralDfa1_0(0x208000L); case 70: case 102: - return jjMoveStringLiteralDfa1_0(0x1002000L); + return jjMoveStringLiteralDfa1_0(0x2002000L); case 72: case 104: return jjMoveStringLiteralDfa1_0(0x20L); case 73: case 105: - return jjMoveStringLiteralDfa1_0(0x400000018000L); + return jjMoveStringLiteralDfa1_0(0x800000030000L); + case 74: + case 106: + return jjMoveStringLiteralDfa1_0(0x4000L); case 76: case 108: - return jjMoveStringLiteralDfa1_0(0x40000000L); + return jjMoveStringLiteralDfa1_0(0x80000000L); case 77: case 109: - return jjMoveStringLiteralDfa1_0(0x30000000000L); + return jjMoveStringLiteralDfa1_0(0x60000000000L); case 78: case 110: - return jjMoveStringLiteralDfa1_0(0x18080020000000L); + return jjMoveStringLiteralDfa1_0(0x30100040000000L); case 79: case 111: - return jjMoveStringLiteralDfa1_0(0x100000000L); + return jjMoveStringLiteralDfa1_0(0x200000000L); case 82: case 114: - return jjMoveStringLiteralDfa1_0(0x2200002000000L); + return jjMoveStringLiteralDfa1_0(0x4400004000000L); case 83: case 115: - return jjMoveStringLiteralDfa1_0(0x480100L); + return jjMoveStringLiteralDfa1_0(0x900100L); case 84: case 116: - return jjMoveStringLiteralDfa1_0(0x10020000L); + return jjMoveStringLiteralDfa1_0(0x20040000L); case 86: case 118: - return jjMoveStringLiteralDfa1_0(0x4000004000000L); + return jjMoveStringLiteralDfa1_0(0x8000008000000L); case 87: case 119: - return jjMoveStringLiteralDfa1_0(0x800000L); + return jjMoveStringLiteralDfa1_0(0x1000000L); default : return jjMoveNfa_0(1, 0); } @@ -333,38 +336,38 @@ switch(curChar) { case 62: - if ((active0 & 0x4000000000L) != 0L) - return jjStopAtPos(1, 38); + if ((active0 & 0x8000000000L) != 0L) + return jjStopAtPos(1, 39); break; case 65: case 97: - return jjMoveStringLiteralDfa2_0(active0, 0x30004020000L); + return jjMoveStringLiteralDfa2_0(active0, 0x60008044000L); case 68: case 100: - return jjMoveStringLiteralDfa2_0(active0, 0x20000000000000L); + return jjMoveStringLiteralDfa2_0(active0, 0x40000000000000L); case 69: case 101: - return jjMoveStringLiteralDfa2_0(active0, 0x62000000c0620L); + return jjMoveStringLiteralDfa2_0(active0, 0xc400000180620L); case 72: case 104: - return jjMoveStringLiteralDfa2_0(active0, 0x40000000800100L); + return jjMoveStringLiteralDfa2_0(active0, 0x80000001000100L); case 73: case 105: - return jjMoveStringLiteralDfa2_0(active0, 0x50200000L); + return jjMoveStringLiteralDfa2_0(active0, 0xa0400000L); case 76: case 108: - return jjMoveStringLiteralDfa2_0(active0, 0x9000000000c0L); + return jjMoveStringLiteralDfa2_0(active0, 0x12000000000c0L); case 78: case 110: - return jjMoveStringLiteralDfa2_0(active0, 0x400080118000L); + return jjMoveStringLiteralDfa2_0(active0, 0x800100230000L); case 79: case 111: - return jjMoveStringLiteralDfa2_0(active0, 0x10c000a000000L); + return jjMoveStringLiteralDfa2_0(active0, 0x2180014000000L); case 82: case 114: - if ((active0 & 0x100000000L) != 0L) - return jjStartNfaWithStates_0(1, 32, 0); - return jjMoveStringLiteralDfa2_0(active0, 0x1001800L); + if ((active0 & 0x200000000L) != 0L) + return jjStartNfaWithStates_0(1, 33, 0); + return jjMoveStringLiteralDfa2_0(active0, 0x2001800L); case 83: case 115: if ((active0 & 0x2000L) != 0L) @@ -372,13 +375,13 @@ break; case 84: case 116: - return jjMoveStringLiteralDfa2_0(active0, 0x400000L); + return jjMoveStringLiteralDfa2_0(active0, 0x800000L); case 85: case 117: - return jjMoveStringLiteralDfa2_0(active0, 0x18000020000000L); + return jjMoveStringLiteralDfa2_0(active0, 0x30000040000000L); case 88: case 120: - return jjMoveStringLiteralDfa2_0(active0, 0x4000L); + return jjMoveStringLiteralDfa2_0(active0, 0x8000L); default : break; } @@ -396,58 +399,63 @@ switch(curChar) { case 95: - return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L); + return jjMoveStringLiteralDfa3_0(active0, 0x800000000000L); case 65: case 97: - return jjMoveStringLiteralDfa3_0(active0, 0x40000000500000L); + return jjMoveStringLiteralDfa3_0(active0, 0x80000000a00000L); case 66: case 98: - return jjMoveStringLiteralDfa3_0(active0, 0x20000L); + return jjMoveStringLiteralDfa3_0(active0, 0x40000L); case 67: case 99: - return jjMoveStringLiteralDfa3_0(active0, 0x4200000000000L); + return jjMoveStringLiteralDfa3_0(active0, 0x8400000000000L); case 68: case 100: - if ((active0 & 0x80000000L) != 0L) - return jjStartNfaWithStates_0(2, 31, 0); - else if ((active0 & 0x20000000000000L) != 0L) - return jjStartNfaWithStates_0(2, 53, 0); + if ((active0 & 0x100000000L) != 0L) + return jjStartNfaWithStates_0(2, 32, 0); + else if ((active0 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_0(2, 54, 0); break; case 69: case 101: - return jjMoveStringLiteralDfa3_0(active0, 0x800880L); + return jjMoveStringLiteralDfa3_0(active0, 0x1000880L); case 73: case 105: - return jjMoveStringLiteralDfa3_0(active0, 0x4000L); + return jjMoveStringLiteralDfa3_0(active0, 0x8000L); case 76: case 108: - return jjMoveStringLiteralDfa3_0(active0, 0xc0c0020L); + return jjMoveStringLiteralDfa3_0(active0, 0x18180020L); case 77: case 109: - return jjMoveStringLiteralDfa3_0(active0, 0x18040070000000L); + return jjMoveStringLiteralDfa3_0(active0, 0x300800e0000000L); case 78: case 110: - return jjMoveStringLiteralDfa3_0(active0, 0x80000000000L); + return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L); case 79: case 111: - return jjMoveStringLiteralDfa3_0(active0, 0x900001001100L); + return jjMoveStringLiteralDfa3_0(active0, 0x1200002001100L); + case 82: + case 114: + if ((active0 & 0x4000L) != 0L) + return jjStartNfaWithStates_0(2, 14, 0); + break; case 83: case 115: - return jjMoveStringLiteralDfa3_0(active0, 0x208600L); + return jjMoveStringLiteralDfa3_0(active0, 0x410600L); case 84: case 116: - return jjMoveStringLiteralDfa3_0(active0, 0x2000000010040L); + return jjMoveStringLiteralDfa3_0(active0, 0x4000000020040L); case 85: case 117: - return jjMoveStringLiteralDfa3_0(active0, 0x1000000000000L); + return jjMoveStringLiteralDfa3_0(active0, 0x2000000000000L); case 87: case 119: - if ((active0 & 0x2000000L) != 0L) - return jjStartNfaWithStates_0(2, 25, 0); + if ((active0 & 0x4000000L) != 0L) + return jjStartNfaWithStates_0(2, 26, 0); break; case 88: case 120: - return jjMoveStringLiteralDfa3_0(active0, 0x30000000000L); + return jjMoveStringLiteralDfa3_0(active0, 0x60000000000L); default : break; } @@ -465,13 +473,13 @@ switch(curChar) { case 95: - return jjMoveStringLiteralDfa4_0(active0, 0x18030020000000L); + return jjMoveStringLiteralDfa4_0(active0, 0x30060040000000L); case 65: case 97: - return jjMoveStringLiteralDfa4_0(active0, 0x200880L); + return jjMoveStringLiteralDfa4_0(active0, 0x400880L); case 66: case 98: - return jjMoveStringLiteralDfa4_0(active0, 0x100000L); + return jjMoveStringLiteralDfa4_0(active0, 0x200000L); case 67: case 99: if ((active0 & 0x400L) != 0L) @@ -479,49 +487,49 @@ jjmatchedKind = 10; jjmatchedPos = 3; } - return jjMoveStringLiteralDfa4_0(active0, 0x100000000200L); + return jjMoveStringLiteralDfa4_0(active0, 0x200000000200L); case 69: case 101: - if ((active0 & 0x80000000000L) != 0L) - return jjStartNfaWithStates_0(3, 43, 0); - return jjMoveStringLiteralDfa4_0(active0, 0x100c8040L); + if ((active0 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_0(3, 44, 0); + return jjMoveStringLiteralDfa4_0(active0, 0x20190040L); case 73: case 105: - return jjMoveStringLiteralDfa4_0(active0, 0x40000000L); + return jjMoveStringLiteralDfa4_0(active0, 0x80000000L); case 76: case 108: - return jjMoveStringLiteralDfa4_0(active0, 0x20000L); + return jjMoveStringLiteralDfa4_0(active0, 0x40000L); case 77: case 109: - if ((active0 & 0x1000000L) != 0L) - return jjStartNfaWithStates_0(3, 24, 0); - return jjMoveStringLiteralDfa4_0(active0, 0x400000000000L); + if ((active0 & 0x2000000L) != 0L) + return jjStartNfaWithStates_0(3, 25, 0); + return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L); case 78: case 110: - return jjMoveStringLiteralDfa4_0(active0, 0x41000000000000L); + return jjMoveStringLiteralDfa4_0(active0, 0x82000000000000L); case 79: case 111: - if ((active0 & 0x10000L) != 0L) - return jjStartNfaWithStates_0(3, 16, 0); - return jjMoveStringLiteralDfa4_0(active0, 0x2a00000000000L); + if ((active0 & 0x20000L) != 0L) + return jjStartNfaWithStates_0(3, 17, 0); + return jjMoveStringLiteralDfa4_0(active0, 0x5400000000000L); case 80: case 112: if ((active0 & 0x20L) != 0L) return jjStartNfaWithStates_0(3, 5, 0); else if ((active0 & 0x1000L) != 0L) return jjStartNfaWithStates_0(3, 12, 0); - return jjMoveStringLiteralDfa4_0(active0, 0x40000000000L); + return jjMoveStringLiteralDfa4_0(active0, 0x80000000000L); case 82: case 114: - return jjMoveStringLiteralDfa4_0(active0, 0xc00000L); + return jjMoveStringLiteralDfa4_0(active0, 0x1800000L); case 84: case 116: - if ((active0 & 0x4000L) != 0L) - return jjStartNfaWithStates_0(3, 14, 0); - return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L); + if ((active0 & 0x8000L) != 0L) + return jjStartNfaWithStates_0(3, 15, 0); + return jjMoveStringLiteralDfa4_0(active0, 0x8000000000000L); case 85: case 117: - return jjMoveStringLiteralDfa4_0(active0, 0xc000000L); + return jjMoveStringLiteralDfa4_0(active0, 0x18000000L); case 87: case 119: if ((active0 & 0x100L) != 0L) @@ -545,58 +553,58 @@ { case 66: case 98: - return jjMoveStringLiteralDfa5_0(active0, 0x200000L); + return jjMoveStringLiteralDfa5_0(active0, 0x400000L); case 67: case 99: - return jjMoveStringLiteralDfa5_0(active0, 0x80000L); + return jjMoveStringLiteralDfa5_0(active0, 0x100000L); case 69: case 101: - if ((active0 & 0x20000L) != 0L) - return jjStartNfaWithStates_0(4, 17, 0); - else if ((active0 & 0x800000L) != 0L) - return jjStartNfaWithStates_0(4, 23, 0); - return jjMoveStringLiteralDfa5_0(active0, 0x10400004000000L); + if ((active0 & 0x40000L) != 0L) + return jjStartNfaWithStates_0(4, 18, 0); + else if ((active0 & 0x1000000L) != 0L) + return jjStartNfaWithStates_0(4, 24, 0); + return jjMoveStringLiteralDfa5_0(active0, 0x20800008000000L); case 71: case 103: - return jjMoveStringLiteralDfa5_0(active0, 0x40000000000000L); + return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L); case 72: case 104: - return jjMoveStringLiteralDfa5_0(active0, 0x8000000000000L); + return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L); case 75: case 107: - if ((active0 & 0x100000000000L) != 0L) - return jjStartNfaWithStates_0(4, 44, 0); + if ((active0 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_0(4, 45, 0); break; case 76: case 108: - return jjMoveStringLiteralDfa5_0(active0, 0x20000100000L); + return jjMoveStringLiteralDfa5_0(active0, 0x40000200000L); case 77: case 109: - return jjMoveStringLiteralDfa5_0(active0, 0x800008000000L); + return jjMoveStringLiteralDfa5_0(active0, 0x1000010000000L); case 79: case 111: - return jjMoveStringLiteralDfa5_0(active0, 0x4000000000000L); + return jjMoveStringLiteralDfa5_0(active0, 0x8000000000000L); case 82: case 114: if ((active0 & 0x40L) != 0L) return jjStartNfaWithStates_0(4, 6, 0); else if ((active0 & 0x80L) != 0L) return jjStartNfaWithStates_0(4, 7, 0); - return jjMoveStringLiteralDfa5_0(active0, 0x240000008200L); + return jjMoveStringLiteralDfa5_0(active0, 0x480000010200L); case 83: case 115: - return jjMoveStringLiteralDfa5_0(active0, 0x10000000L); + return jjMoveStringLiteralDfa5_0(active0, 0x20000000L); case 84: case 116: - if ((active0 & 0x40000000L) != 0L) - return jjStartNfaWithStates_0(4, 30, 0); - return jjMoveStringLiteralDfa5_0(active0, 0x1000000440800L); + if ((active0 & 0x80000000L) != 0L) + return jjStartNfaWithStates_0(4, 31, 0); + return jjMoveStringLiteralDfa5_0(active0, 0x2000000880800L); case 85: case 117: - return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000L); + return jjMoveStringLiteralDfa5_0(active0, 0x4000000000000L); case 86: case 118: - return jjMoveStringLiteralDfa5_0(active0, 0x10020000000L); + return jjMoveStringLiteralDfa5_0(active0, 0x20040000000L); default : break; } @@ -615,56 +623,56 @@ { case 65: case 97: - return jjMoveStringLiteralDfa6_0(active0, 0x8000000000000L); + return jjMoveStringLiteralDfa6_0(active0, 0x10000000000000L); case 67: case 99: - return jjMoveStringLiteralDfa6_0(active0, 0x2000000000000L); + return jjMoveStringLiteralDfa6_0(active0, 0x4000000000000L); case 68: case 100: - if ((active0 & 0x200000000000L) != 0L) - return jjStartNfaWithStates_0(5, 45, 0); + if ((active0 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_0(5, 46, 0); break; case 69: case 101: if ((active0 & 0x800L) != 0L) return jjStartNfaWithStates_0(5, 11, 0); - else if ((active0 & 0x40000L) != 0L) - return jjStartNfaWithStates_0(5, 18, 0); - else if ((active0 & 0x100000L) != 0L) - return jjStartNfaWithStates_0(5, 20, 0); - else if ((active0 & 0x40000000000000L) != 0L) - return jjStartNfaWithStates_0(5, 54, 0); - return jjMoveStringLiteralDfa6_0(active0, 0x70020000000L); + else if ((active0 & 0x80000L) != 0L) + return jjStartNfaWithStates_0(5, 19, 0); + else if ((active0 & 0x200000L) != 0L) + return jjStartNfaWithStates_0(5, 21, 0); + else if ((active0 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 55, 0); + return jjMoveStringLiteralDfa6_0(active0, 0xe0040000000L); case 70: case 102: - return jjMoveStringLiteralDfa6_0(active0, 0x800000000000L); + return jjMoveStringLiteralDfa6_0(active0, 0x1000000000000L); case 73: case 105: - return jjMoveStringLiteralDfa6_0(active0, 0x1000000400200L); + return jjMoveStringLiteralDfa6_0(active0, 0x2000000800200L); case 76: case 108: - return jjMoveStringLiteralDfa6_0(active0, 0x200000L); + return jjMoveStringLiteralDfa6_0(active0, 0x400000L); case 77: case 109: - return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L); + return jjMoveStringLiteralDfa6_0(active0, 0x800000000000L); case 78: case 110: - return jjMoveStringLiteralDfa6_0(active0, 0x10000008000000L); + return jjMoveStringLiteralDfa6_0(active0, 0x20000010000000L); case 82: case 114: - return jjMoveStringLiteralDfa6_0(active0, 0x4000000000000L); + return jjMoveStringLiteralDfa6_0(active0, 0x8000000000000L); case 83: case 115: - if ((active0 & 0x4000000L) != 0L) - return jjStartNfaWithStates_0(5, 26, 0); + if ((active0 & 0x8000000L) != 0L) + return jjStartNfaWithStates_0(5, 27, 0); break; case 84: case 116: - if ((active0 & 0x8000L) != 0L) - return jjStartNfaWithStates_0(5, 15, 0); - else if ((active0 & 0x80000L) != 0L) - return jjStartNfaWithStates_0(5, 19, 0); - return jjMoveStringLiteralDfa6_0(active0, 0x10000000L); + if ((active0 & 0x10000L) != 0L) + return jjStartNfaWithStates_0(5, 16, 0); + else if ((active0 & 0x100000L) != 0L) + return jjStartNfaWithStates_0(5, 20, 0); + return jjMoveStringLiteralDfa6_0(active0, 0x20000000L); default : break; } @@ -682,42 +690,42 @@ switch(curChar) { case 95: - return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000L); + return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000L); case 65: case 97: - return jjMoveStringLiteralDfa7_0(active0, 0x10000000L); + return jjMoveStringLiteralDfa7_0(active0, 0x20000000L); case 66: case 98: return jjMoveStringLiteralDfa7_0(active0, 0x200L); case 69: case 101: - if ((active0 & 0x200000L) != 0L) - return jjStartNfaWithStates_0(6, 21, 0); + if ((active0 & 0x400000L) != 0L) + return jjStartNfaWithStates_0(6, 22, 0); break; case 70: case 102: - return jjMoveStringLiteralDfa7_0(active0, 0x8000000L); + return jjMoveStringLiteralDfa7_0(active0, 0x10000000L); case 72: case 104: - return jjMoveStringLiteralDfa7_0(active0, 0x2000000000000L); + return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000L); case 73: case 105: - return jjMoveStringLiteralDfa7_0(active0, 0x800000000000L); + return jjMoveStringLiteralDfa7_0(active0, 0x1000000000000L); case 78: case 110: - return jjMoveStringLiteralDfa7_0(active0, 0x1020000400000L); + return jjMoveStringLiteralDfa7_0(active0, 0x2040000800000L); case 79: case 111: - return jjMoveStringLiteralDfa7_0(active0, 0x400000000000L); + return jjMoveStringLiteralDfa7_0(active0, 0x800000000000L); case 82: case 114: - return jjMoveStringLiteralDfa7_0(active0, 0x10020000000L); + return jjMoveStringLiteralDfa7_0(active0, 0x20040000000L); case 83: case 115: - return jjMoveStringLiteralDfa7_0(active0, 0x8040000000000L); + return jjMoveStringLiteralDfa7_0(active0, 0x10080000000000L); case 84: case 116: - return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L); + return jjMoveStringLiteralDfa7_0(active0, 0x20000000000000L); default : break; } @@ -736,34 +744,34 @@ { case 65: case 97: - return jjMoveStringLiteralDfa8_0(active0, 0x8000000L); + return jjMoveStringLiteralDfa8_0(active0, 0x10000000L); case 69: case 101: if ((active0 & 0x200L) != 0L) return jjStartNfaWithStates_0(7, 9, 0); - return jjMoveStringLiteralDfa8_0(active0, 0x2000000000000L); + return jjMoveStringLiteralDfa8_0(active0, 0x4000000000000L); case 71: case 103: - if ((active0 & 0x400000L) != 0L) - return jjStartNfaWithStates_0(7, 22, 0); - return jjMoveStringLiteralDfa8_0(active0, 0x1020000000000L); + if ((active0 & 0x800000L) != 0L) + return jjStartNfaWithStates_0(7, 23, 0); + return jjMoveStringLiteralDfa8_0(active0, 0x2040000000000L); case 72: case 104: - if ((active0 & 0x8000000000000L) != 0L) - return jjStartNfaWithStates_0(7, 51, 0); + if ((active0 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_0(7, 52, 0); break; case 76: case 108: - return jjMoveStringLiteralDfa8_0(active0, 0x800000000000L); + return jjMoveStringLiteralDfa8_0(active0, 0x1000000000000L); case 77: case 109: - return jjMoveStringLiteralDfa8_0(active0, 0x10000000L); + return jjMoveStringLiteralDfa8_0(active0, 0x20000000L); case 82: case 114: - return jjMoveStringLiteralDfa8_0(active0, 0x10400000000000L); + return jjMoveStringLiteralDfa8_0(active0, 0x20800000000000L); case 83: case 115: - return jjMoveStringLiteralDfa8_0(active0, 0x4050020000000L); + return jjMoveStringLiteralDfa8_0(active0, 0x80a0040000000L); default : break; } @@ -781,28 +789,28 @@ switch(curChar) { case 95: - return jjMoveStringLiteralDfa9_0(active0, 0x1000000000000L); + return jjMoveStringLiteralDfa9_0(active0, 0x2000000000000L); case 68: case 100: - return jjMoveStringLiteralDfa9_0(active0, 0x2000000000000L); + return jjMoveStringLiteralDfa9_0(active0, 0x4000000000000L); case 73: case 105: - return jjMoveStringLiteralDfa9_0(active0, 0x14050020000000L); + return jjMoveStringLiteralDfa9_0(active0, 0x280a0040000000L); case 77: case 109: - return jjMoveStringLiteralDfa9_0(active0, 0x8000000L); + return jjMoveStringLiteralDfa9_0(active0, 0x10000000L); case 80: case 112: - if ((active0 & 0x10000000L) != 0L) - return jjStartNfaWithStates_0(8, 28, 0); + if ((active0 & 0x20000000L) != 0L) + return jjStartNfaWithStates_0(8, 29, 0); break; case 84: case 116: - return jjMoveStringLiteralDfa9_0(active0, 0x820000000000L); + return jjMoveStringLiteralDfa9_0(active0, 0x1040000000000L); case 89: case 121: - if ((active0 & 0x400000000000L) != 0L) - return jjStartNfaWithStates_0(8, 46, 0); + if ((active0 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_0(8, 47, 0); break; default : break; @@ -821,27 +829,27 @@ switch(curChar) { case 95: - return jjMoveStringLiteralDfa10_0(active0, 0x2000000000000L); + return jjMoveStringLiteralDfa10_0(active0, 0x4000000000000L); case 66: case 98: - return jjMoveStringLiteralDfa10_0(active0, 0x1000000000000L); + return jjMoveStringLiteralDfa10_0(active0, 0x2000000000000L); case 69: case 101: - return jjMoveStringLiteralDfa10_0(active0, 0x10800000000000L); + return jjMoveStringLiteralDfa10_0(active0, 0x21000000000000L); case 72: case 104: - if ((active0 & 0x20000000000L) != 0L) - return jjStartNfaWithStates_0(9, 41, 0); + if ((active0 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_0(9, 42, 0); break; case 73: case 105: - return jjMoveStringLiteralDfa10_0(active0, 0x8000000L); + return jjMoveStringLiteralDfa10_0(active0, 0x10000000L); case 79: case 111: - return jjMoveStringLiteralDfa10_0(active0, 0x50020000000L); + return jjMoveStringLiteralDfa10_0(active0, 0xa0040000000L); case 90: case 122: - return jjMoveStringLiteralDfa10_0(active0, 0x4000000000000L); + return jjMoveStringLiteralDfa10_0(active0, 0x8000000000000L); default : break; } @@ -860,29 +868,29 @@ { case 66: case 98: - return jjMoveStringLiteralDfa11_0(active0, 0x2000000000000L); + return jjMoveStringLiteralDfa11_0(active0, 0x4000000000000L); case 69: case 101: - if ((active0 & 0x4000000000000L) != 0L) - return jjStartNfaWithStates_0(10, 50, 0); + if ((active0 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_0(10, 51, 0); break; case 76: case 108: - return jjMoveStringLiteralDfa11_0(active0, 0x1000008000000L); + return jjMoveStringLiteralDfa11_0(active0, 0x2000010000000L); case 78: case 110: - if ((active0 & 0x40000000000L) != 0L) - return jjStartNfaWithStates_0(10, 42, 0); - return jjMoveStringLiteralDfa11_0(active0, 0x10020000000L); + if ((active0 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_0(10, 43, 0); + return jjMoveStringLiteralDfa11_0(active0, 0x20040000000L); case 82: case 114: - if ((active0 & 0x800000000000L) != 0L) - return jjStartNfaWithStates_0(10, 47, 0); + if ((active0 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_0(10, 48, 0); break; case 83: case 115: - if ((active0 & 0x10000000000000L) != 0L) - return jjStartNfaWithStates_0(10, 52, 0); + if ((active0 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_0(10, 53, 0); break; default : break; @@ -902,19 +910,19 @@ { case 73: case 105: - return jjMoveStringLiteralDfa12_0(active0, 0x8000000L); + return jjMoveStringLiteralDfa12_0(active0, 0x10000000L); case 76: case 108: - return jjMoveStringLiteralDfa12_0(active0, 0x2000000000000L); + return jjMoveStringLiteralDfa12_0(active0, 0x4000000000000L); case 79: case 111: - return jjMoveStringLiteralDfa12_0(active0, 0x1000000000000L); + return jjMoveStringLiteralDfa12_0(active0, 0x2000000000000L); case 83: case 115: - if ((active0 & 0x20000000L) != 0L) - return jjStartNfaWithStates_0(11, 29, 0); - else if ((active0 & 0x10000000000L) != 0L) - return jjStartNfaWithStates_0(11, 40, 0); + if ((active0 & 0x40000000L) != 0L) + return jjStartNfaWithStates_0(11, 30, 0); + else if ((active0 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_0(11, 41, 0); break; default : break; @@ -934,10 +942,10 @@ { case 69: case 101: - return jjMoveStringLiteralDfa13_0(active0, 0x8000000L); + return jjMoveStringLiteralDfa13_0(active0, 0x10000000L); case 79: case 111: - return jjMoveStringLiteralDfa13_0(active0, 0x3000000000000L); + return jjMoveStringLiteralDfa13_0(active0, 0x6000000000000L); default : break; } @@ -956,14 +964,14 @@ { case 77: case 109: - return jjMoveStringLiteralDfa14_0(active0, 0x1000000000000L); + return jjMoveStringLiteralDfa14_0(active0, 0x2000000000000L); case 79: case 111: - return jjMoveStringLiteralDfa14_0(active0, 0x2000000000000L); + return jjMoveStringLiteralDfa14_0(active0, 0x4000000000000L); case 83: case 115: - if ((active0 & 0x8000000L) != 0L) - return jjStartNfaWithStates_0(13, 27, 0); + if ((active0 & 0x10000000L) != 0L) + return jjStartNfaWithStates_0(13, 28, 0); break; default : break; @@ -983,10 +991,10 @@ { case 70: case 102: - return jjMoveStringLiteralDfa15_0(active0, 0x1000000000000L); + return jjMoveStringLiteralDfa15_0(active0, 0x2000000000000L); case 77: case 109: - return jjMoveStringLiteralDfa15_0(active0, 0x2000000000000L); + return jjMoveStringLiteralDfa15_0(active0, 0x4000000000000L); default : break; } @@ -1005,10 +1013,10 @@ { case 70: case 102: - return jjMoveStringLiteralDfa16_0(active0, 0x2000000000000L); + return jjMoveStringLiteralDfa16_0(active0, 0x4000000000000L); case 73: case 105: - return jjMoveStringLiteralDfa16_0(active0, 0x1000000000000L); + return jjMoveStringLiteralDfa16_0(active0, 0x2000000000000L); default : break; } @@ -1027,10 +1035,10 @@ { case 73: case 105: - return jjMoveStringLiteralDfa17_0(active0, 0x2000000000000L); + return jjMoveStringLiteralDfa17_0(active0, 0x4000000000000L); case 76: case 108: - return jjMoveStringLiteralDfa17_0(active0, 0x1000000000000L); + return jjMoveStringLiteralDfa17_0(active0, 0x2000000000000L); default : break; } @@ -1049,10 +1057,10 @@ { case 76: case 108: - return jjMoveStringLiteralDfa18_0(active0, 0x2000000000000L); + return jjMoveStringLiteralDfa18_0(active0, 0x4000000000000L); case 84: case 116: - return jjMoveStringLiteralDfa18_0(active0, 0x1000000000000L); + return jjMoveStringLiteralDfa18_0(active0, 0x2000000000000L); default : break; } @@ -1071,10 +1079,10 @@ { case 69: case 101: - return jjMoveStringLiteralDfa19_0(active0, 0x1000000000000L); + return jjMoveStringLiteralDfa19_0(active0, 0x2000000000000L); case 84: case 116: - return jjMoveStringLiteralDfa19_0(active0, 0x2000000000000L); + return jjMoveStringLiteralDfa19_0(active0, 0x4000000000000L); default : break; } @@ -1093,11 +1101,11 @@ { case 69: case 101: - return jjMoveStringLiteralDfa20_0(active0, 0x2000000000000L); + return jjMoveStringLiteralDfa20_0(active0, 0x4000000000000L); case 82: case 114: - if ((active0 & 0x1000000000000L) != 0L) - return jjStartNfaWithStates_0(19, 48, 0); + if ((active0 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_0(19, 49, 0); break; default : break; @@ -1117,8 +1125,8 @@ { case 82: case 114: - if ((active0 & 0x2000000000000L) != 0L) - return jjStartNfaWithStates_0(20, 49, 0); + if ((active0 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_0(20, 50, 0); break; default : break; @@ -1178,51 +1186,51 @@ switch(jjstateSet[--i]) { case 31: + if ((0x7ffe00000000000L & l) != 0L) + { + if (kind > 56) + kind = 56; + jjCheckNAdd(0); + } if ((0x3ff000000000000L & l) != 0L) { - if (kind > 57) - kind = 57; + if (kind > 58) + kind = 58; jjCheckNAddTwoStates(2, 3); } - else if ((0x400e00000000000L & l) != 0L) - { - if (kind > 55) - kind = 55; - jjCheckNAdd(0); - } break; case 1: - if ((0x3ff000000000000L & l) != 0L) + if ((0x7ffe00000000000L & l) != 0L) { if (kind > 56) kind = 56; - jjCheckNAddStates(0, 6); - } - else if ((0x400e00000000000L & l) != 0L) - { - if (kind > 55) - kind = 55; jjCheckNAdd(0); } else if (curChar == 39) - jjCheckNAddStates(7, 9); + jjCheckNAddStates(0, 2); else if (curChar == 34) jjCheckNAdd(7); - if (curChar == 46) + if ((0x3ff000000000000L & l) != 0L) + { + if (kind > 57) + kind = 57; + jjCheckNAddStates(3, 9); + } + else if (curChar == 46) jjCheckNAdd(2); break; case 0: - if ((0x400e00000000000L & l) == 0L) + if ((0x7ffe00000000000L & l) == 0L) break; - if (kind > 55) - kind = 55; + if (kind > 56) + kind = 56; jjCheckNAdd(0); break; case 2: if ((0x3ff000000000000L & l) == 0L) break; - if (kind > 57) - kind = 57; + if (kind > 58) + kind = 58; jjCheckNAddTwoStates(2, 3); break; case 4: @@ -1232,8 +1240,8 @@ case 5: if ((0x3ff000000000000L & l) == 0L) break; - if (kind > 57) - kind = 57; + if (kind > 58) + kind = 58; jjCheckNAdd(5); break; case 6: @@ -1245,16 +1253,16 @@ jjCheckNAddTwoStates(7, 8); break; case 8: - if (curChar == 34 && kind > 59) - kind = 59; + if (curChar == 34 && kind > 60) + kind = 60; break; case 9: if (curChar == 39) - jjCheckNAddStates(7, 9); + jjCheckNAddStates(0, 2); break; case 10: if ((0xffffff7fffffffffL & l) != 0L) - jjCheckNAddStates(7, 9); + jjCheckNAddStates(0, 2); break; case 11: if (curChar == 39) @@ -1269,21 +1277,21 @@ jjCheckNAddStates(10, 12); break; case 14: - if (curChar == 39 && kind > 60) - kind = 60; + if (curChar == 39 && kind > 61) + kind = 61; break; case 15: if ((0x3ff000000000000L & l) == 0L) break; - if (kind > 56) - kind = 56; - jjCheckNAddStates(0, 6); + if (kind > 57) + kind = 57; + jjCheckNAddStates(3, 9); break; case 16: if ((0x3ff000000000000L & l) == 0L) break; - if (kind > 56) - kind = 56; + if (kind > 57) + kind = 57; jjCheckNAdd(16); break; case 17: @@ -1297,8 +1305,8 @@ case 19: if ((0x3ff000000000000L & l) == 0L) break; - if (kind > 57) - kind = 57; + if (kind > 58) + kind = 58; jjCheckNAddTwoStates(19, 20); break; case 21: @@ -1308,8 +1316,8 @@ case 22: if ((0x3ff000000000000L & l) == 0L) break; - if (kind > 57) - kind = 57; + if (kind > 58) + kind = 58; jjCheckNAdd(22); break; case 23: @@ -1323,15 +1331,15 @@ case 26: if ((0x3ff000000000000L & l) == 0L) break; - if (kind > 57) - kind = 57; + if (kind > 58) + kind = 58; jjCheckNAdd(26); break; case 27: if ((0x3ff000000000000L & l) == 0L) break; - if (kind > 57) - kind = 57; + if (kind > 58) + kind = 58; jjCheckNAddTwoStates(27, 28); break; case 29: @@ -1341,8 +1349,8 @@ case 30: if ((0x3ff000000000000L & l) == 0L) break; - if (kind > 57) - kind = 57; + if (kind > 58) + kind = 58; jjCheckNAdd(30); break; default : break; @@ -1360,15 +1368,15 @@ case 0: if ((0x7fffffe87fffffeL & l) == 0L) break; - if (kind > 55) - kind = 55; + if (kind > 56) + kind = 56; jjCheckNAdd(0); break; case 1: if ((0x7fffffe87fffffeL & l) == 0L) break; - if (kind > 55) - kind = 55; + if (kind > 56) + kind = 56; jjCheckNAdd(0); break; case 3: @@ -1379,7 +1387,7 @@ jjAddStates(15, 16); break; case 10: - jjCheckNAddStates(7, 9); + jjCheckNAddStates(0, 2); break; case 13: jjCheckNAddStates(10, 12); @@ -1414,7 +1422,7 @@ break; case 10: if ((jjbitVec0[i2] & l2) != 0L) - jjCheckNAddStates(7, 9); + jjCheckNAddStates(0, 2); break; case 13: if ((jjbitVec0[i2] & l2) != 0L) @@ -1438,20 +1446,20 @@ } } static final int[] jjnextStates = { - 16, 17, 18, 23, 24, 27, 28, 10, 12, 14, 12, 13, 14, 4, 5, 7, + 10, 12, 14, 16, 17, 18, 23, 24, 27, 28, 12, 13, 14, 4, 5, 7, 8, 21, 22, 25, 26, 29, 30, }; public static final String[] jjstrLiteralImages = { "", null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, -null, null, null, null, null, null, "\54", "\56", "\50", "\51", "\75", "\74\76", -"\52", null, null, null, null, null, null, null, null, null, null, null, null, null, -null, null, null, null, null, null, null, null, "\73", }; +null, null, null, null, null, null, null, "\54", "\56", "\50", "\51", "\75", +"\74\76", "\52", null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, "\73", }; public static final String[] lexStateNames = { "DEFAULT", }; static final long[] jjtoToken = { - 0x3bffffffffffffe1L, + 0x77ffffffffffffe1L, }; static final long[] jjtoSkip = { 0x1eL, Index: src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/ParserConstants.java =================================================================== --- src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/ParserConstants.java (revision 575916) +++ src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/ParserConstants.java (working copy) @@ -13,53 +13,54 @@ int CREATE = 11; int DROP = 12; int FS = 13; - int EXIT = 14; - int INSERT = 15; - int INTO = 16; - int TABLE = 17; - int DELETE = 18; - int SELECT = 19; - int ENABLE = 20; - int DISABLE = 21; - int STARTING = 22; - int WHERE = 23; - int FROM = 24; - int ROW = 25; - int VALUES = 26; - int COLUMNFAMILIES = 27; - int TIMESTAMP = 28; - int NUM_VERSIONS = 29; - int LIMIT = 30; - int AND = 31; - int OR = 32; - int COMMA = 33; - int DOT = 34; - int LPAREN = 35; - int RPAREN = 36; - int EQUALS = 37; - int NOTEQUAL = 38; - int ASTERISK = 39; - int MAX_VERSIONS = 40; - int MAX_LENGTH = 41; - int COMPRESSION = 42; - int NONE = 43; - int BLOCK = 44; - int RECORD = 45; - int IN_MEMORY = 46; - int BLOOMFILTER = 47; - int COUNTING_BLOOMFILTER = 48; - int RETOUCHED_BLOOMFILTER = 49; - int VECTOR_SIZE = 50; - int NUM_HASH = 51; - int NUM_ENTRIES = 52; - int ADD = 53; - int CHANGE = 54; - int ID = 55; - int INTEGER_LITERAL = 56; - int FLOATING_POINT_LITERAL = 57; - int EXPONENT = 58; - int QUOTED_IDENTIFIER = 59; - int STRING_LITERAL = 60; + int JAR = 14; + int EXIT = 15; + int INSERT = 16; + int INTO = 17; + int TABLE = 18; + int DELETE = 19; + int SELECT = 20; + int ENABLE = 21; + int DISABLE = 22; + int STARTING = 23; + int WHERE = 24; + int FROM = 25; + int ROW = 26; + int VALUES = 27; + int COLUMNFAMILIES = 28; + int TIMESTAMP = 29; + int NUM_VERSIONS = 30; + int LIMIT = 31; + int AND = 32; + int OR = 33; + int COMMA = 34; + int DOT = 35; + int LPAREN = 36; + int RPAREN = 37; + int EQUALS = 38; + int NOTEQUAL = 39; + int ASTERISK = 40; + int MAX_VERSIONS = 41; + int MAX_LENGTH = 42; + int COMPRESSION = 43; + int NONE = 44; + int BLOCK = 45; + int RECORD = 46; + int IN_MEMORY = 47; + int BLOOMFILTER = 48; + int COUNTING_BLOOMFILTER = 49; + int RETOUCHED_BLOOMFILTER = 50; + int VECTOR_SIZE = 51; + int NUM_HASH = 52; + int NUM_ENTRIES = 53; + int ADD = 54; + int CHANGE = 55; + int ID = 56; + int INTEGER_LITERAL = 57; + int FLOATING_POINT_LITERAL = 58; + int EXPONENT = 59; + int QUOTED_IDENTIFIER = 60; + int STRING_LITERAL = 61; int DEFAULT = 0; @@ -78,6 +79,7 @@ "\"create\"", "\"drop\"", "\"fs\"", + "\"jar\"", "\"exit\"", "\"insert\"", "\"into\"", Index: src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/Parser.java =================================================================== --- src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/Parser.java (revision 575916) +++ src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/Parser.java (working copy) @@ -60,13 +60,14 @@ case CREATE: case DROP: case FS: + case JAR: case EXIT: case INSERT: case DELETE: case SELECT: case ENABLE: case DISABLE: - case 61: + case 62: switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case HELP: case ALTER: @@ -77,6 +78,7 @@ case CREATE: case DROP: case FS: + case JAR: case EXIT: case INSERT: case DELETE: @@ -89,7 +91,7 @@ jj_la1[0] = jj_gen; ; } - jj_consume_token(61); + jj_consume_token(62); break; case 0: jj_consume_token(0); @@ -149,6 +151,9 @@ case FS: cmd = fsCommand(); break; + case JAR: + cmd = jarCommand(); + break; default: jj_la1[2] = jj_gen; jj_consume_token(-1); @@ -188,6 +193,41 @@ throw new Error("Missing return statement in function"); } + final public JarCommand jarCommand() throws ParseException { + Token t = null; + JarCommand jar = new JarCommand(); + List query = new ArrayList(); + jj_consume_token(JAR); + label_2: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case ID: + case INTEGER_LITERAL: + ; + break; + default: + jj_la1[4] = jj_gen; + break label_2; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case ID: + t = jj_consume_token(ID); + break; + case INTEGER_LITERAL: + t = jj_consume_token(INTEGER_LITERAL); + break; + default: + jj_la1[5] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + query.add(t.image.toString()); + } + jar.setQuery(query); + {if (true) return jar;} + throw new Error("Missing return statement in function"); + } + final public HelpCommand helpCommand() throws ParseException { Token t = null; HelpCommand help = new HelpCommand(); @@ -201,6 +241,7 @@ case CREATE: case DROP: case FS: + case JAR: case EXIT: case INSERT: case DELETE: @@ -240,18 +281,21 @@ case FS: t = jj_consume_token(FS); break; + case JAR: + t = jj_consume_token(JAR); + break; case ID: t = jj_consume_token(ID); break; default: - jj_la1[4] = jj_gen; + jj_la1[6] = jj_gen; jj_consume_token(-1); throw new ParseException(); } argument = t.image.toString(); break; default: - jj_la1[5] = jj_gen; + jj_la1[7] = jj_gen; ; } help.setArgument(argument); @@ -270,7 +314,7 @@ argument = Identifier(); break; default: - jj_la1[6] = jj_gen; + jj_la1[8] = jj_gen; ; } show.setArgument(argument); @@ -289,7 +333,7 @@ jj_consume_token(DESC); break; default: - jj_la1[7] = jj_gen; + jj_la1[9] = jj_gen; jj_consume_token(-1); throw new ParseException(); } @@ -303,7 +347,7 @@ Map columnSpec = new HashMap(); int n = -1; Token t = null; - label_2: + label_3: while (true) { switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case MAX_VERSIONS: @@ -317,8 +361,8 @@ ; break; default: - jj_la1[8] = jj_gen; - break label_2; + jj_la1[10] = jj_gen; + break label_3; } switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case MAX_VERSIONS: @@ -347,7 +391,7 @@ t = jj_consume_token(RECORD); break; default: - jj_la1[9] = jj_gen; + jj_la1[11] = jj_gen; jj_consume_token(-1); throw new ParseException(); } @@ -371,7 +415,7 @@ t = jj_consume_token(RETOUCHED_BLOOMFILTER); break; default: - jj_la1[10] = jj_gen; + jj_la1[12] = jj_gen; jj_consume_token(-1); throw new ParseException(); } @@ -396,7 +440,7 @@ columnSpec.put("NUM_ENTRIES", n); break; default: - jj_la1[11] = jj_gen; + jj_la1[13] = jj_gen; jj_consume_token(-1); throw new ParseException(); } @@ -418,15 +462,15 @@ column = Identifier(); columnSpec = ColumnSpec(); createCommand.addColumnSpec(column, columnSpec); - label_3: + label_4: while (true) { switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case COMMA: ; break; default: - jj_la1[12] = jj_gen; - break label_3; + jj_la1[14] = jj_gen; + break label_4; } jj_consume_token(COMMA); column = Identifier(); @@ -462,15 +506,15 @@ column = Identifier(); columnSpec = ColumnSpec(); alterCommand.addColumnSpec(column, columnSpec); - label_4: + label_5: while (true) { switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case COMMA: ; break; default: - jj_la1[13] = jj_gen; - break label_4; + jj_la1[15] = jj_gen; + break label_5; } jj_consume_token(COMMA); column = Identifier(); @@ -493,7 +537,7 @@ alterCommand.addColumnSpec(column, columnSpec); break; default: - jj_la1[14] = jj_gen; + jj_la1[16] = jj_gen; jj_consume_token(-1); throw new ParseException(); } @@ -539,7 +583,7 @@ t = jj_consume_token(QUOTED_IDENTIFIER); break; default: - jj_la1[15] = jj_gen; + jj_la1[17] = jj_gen; jj_consume_token(-1); throw new ParseException(); } @@ -570,7 +614,7 @@ t = jj_consume_token(QUOTED_IDENTIFIER); break; default: - jj_la1[16] = jj_gen; + jj_la1[18] = jj_gen; jj_consume_token(-1); throw new ParseException(); } @@ -608,7 +652,7 @@ jj_consume_token(FROM); break; default: - jj_la1[17] = jj_gen; + jj_la1[19] = jj_gen; jj_consume_token(-1); throw new ParseException(); } @@ -616,7 +660,7 @@ select.setRowKey(rowKey); break; default: - jj_la1[18] = jj_gen; + jj_la1[20] = jj_gen; ; } switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { @@ -626,7 +670,7 @@ select.setTimestamp(timestamp); break; default: - jj_la1[19] = jj_gen; + jj_la1[21] = jj_gen; ; } switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { @@ -636,7 +680,7 @@ select.setVersion(numVersion); break; default: - jj_la1[20] = jj_gen; + jj_la1[22] = jj_gen; ; } switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { @@ -651,7 +695,7 @@ } break; default: - jj_la1[21] = jj_gen; + jj_la1[23] = jj_gen; ; } {if (true) return select;} @@ -693,7 +737,7 @@ jj_consume_token(LPAREN); literal = getStringLiteral(); if(literal != null) values.add(literal); - label_5: + label_6: while (true) { switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case COMMA: @@ -703,8 +747,8 @@ ; break; default: - jj_la1[22] = jj_gen; - break label_5; + jj_la1[24] = jj_gen; + break label_6; } switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case COMMA: @@ -726,14 +770,14 @@ jj_consume_token(QUOTED_IDENTIFIER); break; default: - jj_la1[23] = jj_gen; + jj_la1[25] = jj_gen; jj_consume_token(-1); throw new ParseException(); } values.removeAll(values); break; default: - jj_la1[24] = jj_gen; + jj_la1[26] = jj_gen; jj_consume_token(-1); throw new ParseException(); } @@ -753,7 +797,7 @@ s = jj_consume_token(QUOTED_IDENTIFIER); break; default: - jj_la1[25] = jj_gen; + jj_la1[27] = jj_gen; jj_consume_token(-1); throw new ParseException(); } @@ -768,15 +812,15 @@ jj_consume_token(LPAREN); literal = getColumn(); if(literal != null) values.add(literal); - label_6: + label_7: while (true) { switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case COMMA: ; break; default: - jj_la1[26] = jj_gen; - break label_6; + jj_la1[28] = jj_gen; + break label_7; } jj_consume_token(COMMA); literal = getColumn(); @@ -800,7 +844,7 @@ col = jj_consume_token(ASTERISK); break; default: - jj_la1[27] = jj_gen; + jj_la1[29] = jj_gen; jj_consume_token(-1); throw new ParseException(); } @@ -816,14 +860,14 @@ col = jj_consume_token(STRING_LITERAL); break; default: - jj_la1[28] = jj_gen; + jj_la1[30] = jj_gen; jj_consume_token(-1); throw new ParseException(); } {if (true) return col.image.substring(1,col.image.toString().length() - 1);} break; default: - jj_la1[29] = jj_gen; + jj_la1[31] = jj_gen; jj_consume_token(-1); throw new ParseException(); } @@ -835,15 +879,15 @@ String table = null; table = Identifier(); tableList.add(table); - label_7: + label_8: while (true) { switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case COMMA: ; break; default: - jj_la1[30] = jj_gen; - break label_7; + jj_la1[32] = jj_gen; + break label_8; } jj_consume_token(COMMA); table = Identifier(); @@ -862,15 +906,15 @@ } else { {if (true) return columnList;} } - label_8: + label_9: while (true) { switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case COMMA: ; break; default: - jj_la1[31] = jj_gen; - break label_8; + jj_la1[33] = jj_gen; + break label_9; } jj_consume_token(COMMA); column = getColumn(); @@ -904,14 +948,14 @@ t = jj_consume_token(STRING_LITERAL); break; default: - jj_la1[32] = jj_gen; + jj_la1[34] = jj_gen; jj_consume_token(-1); throw new ParseException(); } {if (true) return t.image.substring(1,t.image.toString().length() - 1);} break; default: - jj_la1[33] = jj_gen; + jj_la1[35] = jj_gen; jj_consume_token(-1); throw new ParseException(); } @@ -925,33 +969,33 @@ finally { jj_save(0, xla); } } - final private boolean jj_3R_9() { + final private boolean jj_3R_10() { Token xsp; xsp = jj_scanpos; - if (jj_3R_10()) { + if (jj_3R_11()) { jj_scanpos = xsp; - if (jj_3R_11()) return true; + if (jj_3R_12()) return true; } return false; } final private boolean jj_3_1() { if (jj_scan_token(ADD)) return true; - if (jj_3R_9()) return true; + if (jj_3R_10()) return true; return false; } - final private boolean jj_3R_11() { + final private boolean jj_3R_12() { Token xsp; xsp = jj_scanpos; - if (jj_scan_token(59)) { + if (jj_scan_token(60)) { jj_scanpos = xsp; - if (jj_scan_token(60)) return true; + if (jj_scan_token(61)) return true; } return false; } - final private boolean jj_3R_10() { + final private boolean jj_3R_11() { if (jj_scan_token(ID)) return true; return false; } @@ -965,7 +1009,7 @@ public boolean lookingAhead = false; private boolean jj_semLA; private int jj_gen; - final private int[] jj_la1 = new int[34]; + final private int[] jj_la1 = new int[36]; static private int[] jj_la1_0; static private int[] jj_la1_1; static { @@ -973,10 +1017,10 @@ jj_la1_1(); } private static void jj_la1_0() { - jj_la1_0 = new int[] {0x3cffe0,0x3cffe1,0x3cffe0,0x0,0xcfbc0,0xcfbc0,0x0,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0xc00000,0xc00000,0x10000000,0x20000000,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + jj_la1_0 = new int[] {0x79ffe0,0x79ffe1,0x79ffe0,0x0,0x0,0x0,0x19fbc0,0x19fbc0,0x0,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x1800000,0x1800000,0x20000000,0x40000000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; } private static void jj_la1_1() { - jj_la1_1 = new int[] {0x0,0x20000000,0x0,0x800000,0x800000,0x800000,0x18800000,0x0,0x1cc700,0x3800,0x38000,0x1cc700,0x2,0x2,0x600000,0x18000000,0x18000000,0x0,0x0,0x0,0x0,0x0,0x18800002,0x18800000,0x18800002,0x18000000,0x2,0x800080,0x18000000,0x18800080,0x2,0x2,0x18000000,0x18800000,}; + jj_la1_1 = new int[] {0x0,0x40000000,0x0,0x1000000,0x3000000,0x3000000,0x1000000,0x1000000,0x31000000,0x0,0x398e00,0x7000,0x70000,0x398e00,0x4,0x4,0xc00000,0x30000000,0x30000000,0x0,0x0,0x0,0x0,0x0,0x31000004,0x31000000,0x31000004,0x30000000,0x4,0x1000100,0x30000000,0x31000100,0x4,0x4,0x30000000,0x31000000,}; } final private JJCalls[] jj_2_rtns = new JJCalls[1]; private boolean jj_rescan = false; @@ -991,7 +1035,7 @@ token = new Token(); jj_ntk = -1; jj_gen = 0; - for (int i = 0; i < 34; i++) jj_la1[i] = -1; + for (int i = 0; i < 36; i++) jj_la1[i] = -1; for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); } @@ -1004,7 +1048,7 @@ token = new Token(); jj_ntk = -1; jj_gen = 0; - for (int i = 0; i < 34; i++) jj_la1[i] = -1; + for (int i = 0; i < 36; i++) jj_la1[i] = -1; for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); } @@ -1014,7 +1058,7 @@ token = new Token(); jj_ntk = -1; jj_gen = 0; - for (int i = 0; i < 34; i++) jj_la1[i] = -1; + for (int i = 0; i < 36; i++) jj_la1[i] = -1; for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); } @@ -1024,7 +1068,7 @@ token = new Token(); jj_ntk = -1; jj_gen = 0; - for (int i = 0; i < 34; i++) jj_la1[i] = -1; + for (int i = 0; i < 36; i++) jj_la1[i] = -1; for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); } @@ -1033,7 +1077,7 @@ token = new Token(); jj_ntk = -1; jj_gen = 0; - for (int i = 0; i < 34; i++) jj_la1[i] = -1; + for (int i = 0; i < 36; i++) jj_la1[i] = -1; for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); } @@ -1042,7 +1086,7 @@ token = new Token(); jj_ntk = -1; jj_gen = 0; - for (int i = 0; i < 34; i++) jj_la1[i] = -1; + for (int i = 0; i < 36; i++) jj_la1[i] = -1; for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); } @@ -1153,15 +1197,15 @@ public ParseException generateParseException() { jj_expentries.removeAllElements(); - boolean[] la1tokens = new boolean[62]; - for (int i = 0; i < 62; i++) { + boolean[] la1tokens = new boolean[63]; + for (int i = 0; i < 63; i++) { la1tokens[i] = false; } if (jj_kind >= 0) { la1tokens[jj_kind] = true; jj_kind = -1; } - for (int i = 0; i < 34; i++) { + for (int i = 0; i < 36; i++) { if (jj_la1[i] == jj_gen) { for (int j = 0; j < 32; j++) { if ((jj_la1_0[i] & (1< | | + | | | | @@ -117,7 +118,7 @@ TOKEN : /** Literals */ { - + | | )? @@ -164,6 +165,7 @@ | cmd = disableCommand() | cmd = clearCommand() | cmd = fsCommand() + | cmd = jarCommand() ) { return cmd; @@ -197,6 +199,25 @@ } } +JarCommand jarCommand() : +{ + Token t = null; + JarCommand jar = new JarCommand(); + List query = new ArrayList(); +} +{ + + ( + ( t = | t = ) + { query.add(t.image.toString()); } + )* + + { + jar.setQuery(query); + return jar; + } +} + HelpCommand helpCommand() : { Token t = null; @@ -218,6 +239,7 @@ | t= | t= | t= + | t= | t= ) { argument = t.image.toString(); } ]