hadoop-common-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dhr...@apache.org
Subject svn commit: r706704 [21/23] - in /hadoop/core/trunk: ./ src/contrib/hive/ src/contrib/hive/bin/ src/contrib/hive/cli/src/java/org/apache/hadoop/hive/cli/ src/contrib/hive/common/src/java/org/apache/hadoop/hive/conf/ src/contrib/hive/conf/ src/contrib/h...
Date Tue, 21 Oct 2008 18:11:18 GMT
Added: hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/dynamic_type/thrift_grammarTokenManager.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/dynamic_type/thrift_grammarTokenManager.java?rev=706704&view=auto
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/dynamic_type/thrift_grammarTokenManager.java (added)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/dynamic_type/thrift_grammarTokenManager.java Tue Oct 21 11:11:05 2008
@@ -0,0 +1,1455 @@
+/* Generated By:JJTree&JavaCC: Do not edit this line. thrift_grammarTokenManager.java */
+package org.apache.hadoop.hive.serde2.dynamic_type;
+import java.util.*;
+import java.io.*;
+import java.net.*;
+import com.facebook.thrift.protocol.*;
+import com.facebook.thrift.transport.*;
+import org.apache.hadoop.hive.serde2.dynamic_type.*;
+
+public class thrift_grammarTokenManager implements thrift_grammarConstants
+{
+  public  java.io.PrintStream debugStream = System.out;
+  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
+private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x7ffffffffff00L) != 0L)
+         {
+            jjmatchedKind = 53;
+            return 35;
+         }
+         return -1;
+      case 1:
+         if ((active0 & 0x7ffffffffff00L) != 0L)
+         {
+            jjmatchedKind = 53;
+            jjmatchedPos = 1;
+            return 35;
+         }
+         return -1;
+      case 2:
+         if ((active0 & 0x14380000000L) != 0L)
+            return 35;
+         if ((active0 & 0x7febc7fffff00L) != 0L)
+         {
+            jjmatchedKind = 53;
+            jjmatchedPos = 2;
+            return 35;
+         }
+         return -1;
+      case 3:
+         if ((active0 & 0x1008070000000L) != 0L)
+            return 35;
+         if ((active0 & 0x6fe3c0fffff00L) != 0L)
+         {
+            jjmatchedKind = 53;
+            jjmatchedPos = 3;
+            return 35;
+         }
+         return -1;
+      case 4:
+         if ((active0 & 0x23000000100L) != 0L)
+            return 35;
+         if ((active0 & 0x6fc0c0ffffe00L) != 0L)
+         {
+            jjmatchedKind = 53;
+            jjmatchedPos = 4;
+            return 35;
+         }
+         return -1;
+      case 5:
+         if ((active0 & 0x480c00000000L) != 0L)
+            return 35;
+         if ((active0 & 0x6b4000ffffe00L) != 0L)
+         {
+            jjmatchedKind = 53;
+            jjmatchedPos = 5;
+            return 35;
+         }
+         return -1;
+      case 6:
+         if ((active0 & 0xa40008400000L) != 0L)
+            return 35;
+         if ((active0 & 0x6100007bffe00L) != 0L)
+         {
+            jjmatchedKind = 53;
+            jjmatchedPos = 6;
+            return 35;
+         }
+         return -1;
+      case 7:
+         if ((active0 & 0x6000000001000L) != 0L)
+            return 35;
+         if ((active0 & 0x100007bfee00L) != 0L)
+         {
+            jjmatchedKind = 53;
+            jjmatchedPos = 7;
+            return 35;
+         }
+         return -1;
+      case 8:
+         if ((active0 & 0x3bdec00L) != 0L)
+         {
+            jjmatchedKind = 53;
+            jjmatchedPos = 8;
+            return 35;
+         }
+         if ((active0 & 0x100004020200L) != 0L)
+            return 35;
+         return -1;
+      case 9:
+         if ((active0 & 0x3bdec00L) != 0L)
+         {
+            jjmatchedKind = 53;
+            jjmatchedPos = 9;
+            return 35;
+         }
+         return -1;
+      case 10:
+         if ((active0 & 0x800L) != 0L)
+            return 35;
+         if ((active0 & 0x3bde400L) != 0L)
+         {
+            jjmatchedKind = 53;
+            jjmatchedPos = 10;
+            return 35;
+         }
+         return -1;
+      case 11:
+         if ((active0 & 0x1846000L) != 0L)
+            return 35;
+         if ((active0 & 0x2398400L) != 0L)
+         {
+            jjmatchedKind = 53;
+            jjmatchedPos = 11;
+            return 35;
+         }
+         return -1;
+      case 12:
+         if ((active0 & 0x2010400L) != 0L)
+            return 35;
+         if ((active0 & 0x388000L) != 0L)
+         {
+            jjmatchedKind = 53;
+            jjmatchedPos = 12;
+            return 35;
+         }
+         return -1;
+      case 13:
+         if ((active0 & 0x80000L) != 0L)
+            return 35;
+         if ((active0 & 0x308000L) != 0L)
+         {
+            jjmatchedKind = 53;
+            jjmatchedPos = 13;
+            return 35;
+         }
+         return -1;
+      case 14:
+         if ((active0 & 0x308000L) != 0L)
+         {
+            jjmatchedKind = 53;
+            jjmatchedPos = 14;
+            return 35;
+         }
+         return -1;
+      case 15:
+         if ((active0 & 0x208000L) != 0L)
+            return 35;
+         if ((active0 & 0x100000L) != 0L)
+         {
+            jjmatchedKind = 53;
+            jjmatchedPos = 15;
+            return 35;
+         }
+         return -1;
+      case 16:
+         if ((active0 & 0x100000L) != 0L)
+         {
+            jjmatchedKind = 53;
+            jjmatchedPos = 16;
+            return 35;
+         }
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_0(int pos, long active0, long active1)
+{
+   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
+}
+private final int jjStopAtPos(int pos, int kind)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   return pos + 1;
+}
+private final int jjStartNfaWithStates_0(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_0(state, pos + 1);
+}
+private final int jjMoveStringLiteralDfa0_0()
+{
+   switch(curChar)
+   {
+      case 40:
+         return jjStopAtPos(0, 66);
+      case 41:
+         return jjStopAtPos(0, 67);
+      case 44:
+         return jjStopAtPos(0, 58);
+      case 58:
+         return jjStopAtPos(0, 65);
+      case 59:
+         return jjStopAtPos(0, 59);
+      case 60:
+         return jjStopAtPos(0, 68);
+      case 61:
+         return jjStopAtPos(0, 62);
+      case 62:
+         return jjStopAtPos(0, 69);
+      case 91:
+         return jjStopAtPos(0, 63);
+      case 93:
+         return jjStopAtPos(0, 64);
+      case 97:
+         return jjMoveStringLiteralDfa1_0(0x20000000000L);
+      case 98:
+         return jjMoveStringLiteralDfa1_0(0x60000000L);
+      case 99:
+         return jjMoveStringLiteralDfa1_0(0xdd00L);
+      case 100:
+         return jjMoveStringLiteralDfa1_0(0x400000000L);
+      case 101:
+         return jjMoveStringLiteralDfa1_0(0x1300000000000L);
+      case 105:
+         return jjMoveStringLiteralDfa1_0(0x388000000L);
+      case 106:
+         return jjMoveStringLiteralDfa1_0(0x2000L);
+      case 108:
+         return jjMoveStringLiteralDfa1_0(0x8000000000L);
+      case 109:
+         return jjMoveStringLiteralDfa1_0(0x4000000000L);
+      case 110:
+         return jjMoveStringLiteralDfa1_0(0x200L);
+      case 111:
+         return jjMoveStringLiteralDfa1_0(0x4000000000000L);
+      case 112:
+         return jjMoveStringLiteralDfa1_0(0x70000L);
+      case 114:
+         return jjMoveStringLiteralDfa1_0(0x2000000080000L);
+      case 115:
+         return jjMoveStringLiteralDfa1_0(0x893800300000L);
+      case 116:
+         return jjMoveStringLiteralDfa1_0(0x440000000000L);
+      case 118:
+         return jjMoveStringLiteralDfa1_0(0x10000000L);
+      case 120:
+         return jjMoveStringLiteralDfa1_0(0x7c00000L);
+      case 123:
+         return jjStopAtPos(0, 60);
+      case 125:
+         return jjStopAtPos(0, 61);
+      default :
+         return jjMoveNfa_0(0, 0);
+   }
+}
+private final int jjMoveStringLiteralDfa1_0(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(0, active0, 0L);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 49:
+         return jjMoveStringLiteralDfa2_0(active0, 0x80000000L);
+      case 51:
+         return jjMoveStringLiteralDfa2_0(active0, 0x100000000L);
+      case 54:
+         return jjMoveStringLiteralDfa2_0(active0, 0x200000000L);
+      case 97:
+         return jjMoveStringLiteralDfa2_0(active0, 0x4000002200L);
+      case 101:
+         return jjMoveStringLiteralDfa2_0(active0, 0x2812000040000L);
+      case 104:
+         return jjMoveStringLiteralDfa2_0(active0, 0x400000010000L);
+      case 105:
+         return jjMoveStringLiteralDfa2_0(active0, 0x8000000000L);
+      case 108:
+         return jjMoveStringLiteralDfa2_0(active0, 0x1000000000L);
+      case 109:
+         return jjMoveStringLiteralDfa2_0(active0, 0x300000L);
+      case 110:
+         return jjMoveStringLiteralDfa2_0(active0, 0x1000008000000L);
+      case 111:
+         return jjMoveStringLiteralDfa2_0(active0, 0x430004100L);
+      case 112:
+         return jjMoveStringLiteralDfa2_0(active0, 0x4000000001c00L);
+      case 115:
+         return jjMoveStringLiteralDfa2_0(active0, 0x20007c08000L);
+      case 116:
+         return jjMoveStringLiteralDfa2_0(active0, 0x80800000000L);
+      case 117:
+         return jjMoveStringLiteralDfa2_0(active0, 0x80000L);
+      case 120:
+         return jjMoveStringLiteralDfa2_0(active0, 0x300000000000L);
+      case 121:
+         return jjMoveStringLiteralDfa2_0(active0, 0x40040020000L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(0, active0, 0L);
+}
+private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(0, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(1, active0, 0L);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 50:
+         if ((active0 & 0x100000000L) != 0L)
+            return jjStartNfaWithStates_0(2, 32, 35);
+         break;
+      case 52:
+         if ((active0 & 0x200000000L) != 0L)
+            return jjStartNfaWithStates_0(2, 33, 35);
+         break;
+      case 54:
+         if ((active0 & 0x80000000L) != 0L)
+            return jjStartNfaWithStates_0(2, 31, 35);
+         break;
+      case 95:
+         return jjMoveStringLiteralDfa3_0(active0, 0x20000L);
+      case 97:
+         return jjMoveStringLiteralDfa3_0(active0, 0x300000L);
+      case 98:
+         return jjMoveStringLiteralDfa3_0(active0, 0x80000L);
+      case 99:
+         return jjMoveStringLiteralDfa3_0(active0, 0x100008004000L);
+      case 100:
+         return jjMoveStringLiteralDfa3_0(active0, 0x7c00000L);
+      case 104:
+         return jjMoveStringLiteralDfa3_0(active0, 0x8000L);
+      case 105:
+         return jjMoveStringLiteralDfa3_0(active0, 0x1010000000L);
+      case 109:
+         return jjMoveStringLiteralDfa3_0(active0, 0x200L);
+      case 110:
+         return jjMoveStringLiteralDfa3_0(active0, 0x2000000100L);
+      case 111:
+         return jjMoveStringLiteralDfa3_0(active0, 0x20000000L);
+      case 112:
+         if ((active0 & 0x4000000000L) != 0L)
+            return jjStartNfaWithStates_0(2, 38, 35);
+         return jjMoveStringLiteralDfa3_0(active0, 0x40000011c00L);
+      case 113:
+         return jjMoveStringLiteralDfa3_0(active0, 0x2000000000000L);
+      case 114:
+         return jjMoveStringLiteralDfa3_0(active0, 0xc80800040000L);
+      case 115:
+         return jjMoveStringLiteralDfa3_0(active0, 0x8000000000L);
+      case 116:
+         if ((active0 & 0x10000000000L) != 0L)
+            return jjStartNfaWithStates_0(2, 40, 35);
+         return jjMoveStringLiteralDfa3_0(active0, 0x4200040000000L);
+      case 117:
+         return jjMoveStringLiteralDfa3_0(active0, 0x1000400000000L);
+      case 118:
+         return jjMoveStringLiteralDfa3_0(active0, 0x2000L);
+      case 121:
+         return jjMoveStringLiteralDfa3_0(active0, 0x20000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(1, active0, 0L);
+}
+private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(1, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(2, active0, 0L);
+      return 3;
+   }
+   switch(curChar)
+   {
+      case 95:
+         return jjMoveStringLiteralDfa4_0(active0, 0x7c11c00L);
+      case 97:
+         return jjMoveStringLiteralDfa4_0(active0, 0xa000L);
+      case 98:
+         return jjMoveStringLiteralDfa4_0(active0, 0x400000000L);
+      case 100:
+         if ((active0 & 0x10000000L) != 0L)
+            return jjStartNfaWithStates_0(3, 28, 35);
+         break;
+      case 101:
+         if ((active0 & 0x40000000L) != 0L)
+            return jjStartNfaWithStates_0(3, 30, 35);
+         return jjMoveStringLiteralDfa4_0(active0, 0x340000000200L);
+      case 105:
+         return jjMoveStringLiteralDfa4_0(active0, 0x4000800000000L);
+      case 108:
+         if ((active0 & 0x20000000L) != 0L)
+            return jjStartNfaWithStates_0(3, 29, 35);
+         return jjMoveStringLiteralDfa4_0(active0, 0x8340000L);
+      case 109:
+         if ((active0 & 0x1000000000000L) != 0L)
+            return jjStartNfaWithStates_0(3, 48, 35);
+         return jjMoveStringLiteralDfa4_0(active0, 0x20000L);
+      case 110:
+         return jjMoveStringLiteralDfa4_0(active0, 0x20000000000L);
+      case 111:
+         return jjMoveStringLiteralDfa4_0(active0, 0x400000004000L);
+      case 115:
+         return jjMoveStringLiteralDfa4_0(active0, 0x1000000100L);
+      case 116:
+         if ((active0 & 0x8000000000L) != 0L)
+            return jjStartNfaWithStates_0(3, 39, 35);
+         break;
+      case 117:
+         return jjMoveStringLiteralDfa4_0(active0, 0x2082000000000L);
+      case 118:
+         return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L);
+      case 121:
+         return jjMoveStringLiteralDfa4_0(active0, 0x80000L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(2, active0, 0L);
+}
+private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(2, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(3, active0, 0L);
+      return 4;
+   }
+   switch(curChar)
+   {
+      case 95:
+         return jjMoveStringLiteralDfa5_0(active0, 0xc2000L);
+      case 97:
+         return jjMoveStringLiteralDfa5_0(active0, 0x4404000L);
+      case 99:
+         if ((active0 & 0x20000000000L) != 0L)
+            return jjStartNfaWithStates_0(4, 41, 35);
+         return jjMoveStringLiteralDfa5_0(active0, 0x80000000000L);
+      case 100:
+         return jjMoveStringLiteralDfa5_0(active0, 0x40000000000L);
+      case 105:
+         return jjMoveStringLiteralDfa5_0(active0, 0x2800000000800L);
+      case 108:
+         return jjMoveStringLiteralDfa5_0(active0, 0x400300000L);
+      case 109:
+         if ((active0 & 0x2000000000L) != 0L)
+            return jjStartNfaWithStates_0(4, 37, 35);
+         break;
+      case 110:
+         return jjMoveStringLiteralDfa5_0(active0, 0x200803010400L);
+      case 111:
+         return jjMoveStringLiteralDfa5_0(active0, 0x4000000820000L);
+      case 112:
+         return jjMoveStringLiteralDfa5_0(active0, 0x100000000000L);
+      case 114:
+         return jjMoveStringLiteralDfa5_0(active0, 0x8000L);
+      case 115:
+         return jjMoveStringLiteralDfa5_0(active0, 0x200L);
+      case 116:
+         if ((active0 & 0x100L) != 0L)
+            return jjStartNfaWithStates_0(4, 8, 35);
+         else if ((active0 & 0x1000000000L) != 0L)
+            return jjStartNfaWithStates_0(4, 36, 35);
+         return jjMoveStringLiteralDfa5_0(active0, 0x1000L);
+      case 117:
+         return jjMoveStringLiteralDfa5_0(active0, 0x8000000L);
+      case 119:
+         return jjMoveStringLiteralDfa5_0(active0, 0x400000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(3, active0, 0L);
+}
+private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(3, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(4, active0, 0L);
+      return 5;
+   }
+   switch(curChar)
+   {
+      case 95:
+         return jjMoveStringLiteralDfa6_0(active0, 0x4000L);
+      case 97:
+         return jjMoveStringLiteralDfa6_0(active0, 0x2010400L);
+      case 99:
+         return jjMoveStringLiteralDfa6_0(active0, 0x800000000000L);
+      case 100:
+         return jjMoveStringLiteralDfa6_0(active0, 0x200008020000L);
+      case 101:
+         if ((active0 & 0x400000000L) != 0L)
+            return jjStartNfaWithStates_0(5, 34, 35);
+         return jjMoveStringLiteralDfa6_0(active0, 0x40000000000L);
+      case 103:
+         if ((active0 & 0x800000000L) != 0L)
+            return jjStartNfaWithStates_0(5, 35, 35);
+         break;
+      case 105:
+         return jjMoveStringLiteralDfa6_0(active0, 0x1000000L);
+      case 108:
+         return jjMoveStringLiteralDfa6_0(active0, 0x400000L);
+      case 110:
+         return jjMoveStringLiteralDfa6_0(active0, 0x4000000080800L);
+      case 112:
+         return jjMoveStringLiteralDfa6_0(active0, 0x84a200L);
+      case 114:
+         return jjMoveStringLiteralDfa6_0(active0, 0x2000000000000L);
+      case 115:
+         if ((active0 & 0x400000000000L) != 0L)
+            return jjStartNfaWithStates_0(5, 46, 35);
+         break;
+      case 116:
+         if ((active0 & 0x80000000000L) != 0L)
+            return jjStartNfaWithStates_0(5, 43, 35);
+         return jjMoveStringLiteralDfa6_0(active0, 0x100004300000L);
+      case 121:
+         return jjMoveStringLiteralDfa6_0(active0, 0x1000L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(4, active0, 0L);
+}
+private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(4, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(5, active0, 0L);
+      return 6;
+   }
+   switch(curChar)
+   {
+      case 95:
+         return jjMoveStringLiteralDfa7_0(active0, 0x8000L);
+      case 97:
+         return jjMoveStringLiteralDfa7_0(active0, 0x40000003c2200L);
+      case 99:
+         return jjMoveStringLiteralDfa7_0(active0, 0x800L);
+      case 101:
+         if ((active0 & 0x8000000L) != 0L)
+            return jjStartNfaWithStates_0(6, 27, 35);
+         else if ((active0 & 0x800000000000L) != 0L)
+            return jjStartNfaWithStates_0(6, 47, 35);
+         return jjMoveStringLiteralDfa7_0(active0, 0x2000000000000L);
+      case 102:
+         if ((active0 & 0x40000000000L) != 0L)
+            return jjStartNfaWithStates_0(6, 42, 35);
+         break;
+      case 105:
+         return jjMoveStringLiteralDfa7_0(active0, 0x100000000000L);
+      case 108:
+         if ((active0 & 0x400000L) != 0L)
+            return jjStartNfaWithStates_0(6, 22, 35);
+         return jjMoveStringLiteralDfa7_0(active0, 0x1000000L);
+      case 109:
+         return jjMoveStringLiteralDfa7_0(active0, 0x2010400L);
+      case 112:
+         return jjMoveStringLiteralDfa7_0(active0, 0x5000L);
+      case 115:
+         if ((active0 & 0x200000000000L) != 0L)
+            return jjStartNfaWithStates_0(6, 45, 35);
+         break;
+      case 116:
+         return jjMoveStringLiteralDfa7_0(active0, 0x4800000L);
+      case 117:
+         return jjMoveStringLiteralDfa7_0(active0, 0x20000L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(5, active0, 0L);
+}
+private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(5, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(6, active0, 0L);
+      return 7;
+   }
+   switch(curChar)
+   {
+      case 99:
+         return jjMoveStringLiteralDfa8_0(active0, 0x42200L);
+      case 100:
+         if ((active0 & 0x2000000000000L) != 0L)
+            return jjStartNfaWithStates_0(7, 49, 35);
+         break;
+      case 101:
+         if ((active0 & 0x1000L) != 0L)
+            return jjStartNfaWithStates_0(7, 12, 35);
+         return jjMoveStringLiteralDfa8_0(active0, 0x2010400L);
+      case 105:
+         return jjMoveStringLiteralDfa8_0(active0, 0x800000L);
+      case 108:
+         if ((active0 & 0x4000000000000L) != 0L)
+            return jjStartNfaWithStates_0(7, 50, 35);
+         return jjMoveStringLiteralDfa8_0(active0, 0x1320800L);
+      case 109:
+         return jjMoveStringLiteralDfa8_0(active0, 0x80000L);
+      case 110:
+         return jjMoveStringLiteralDfa8_0(active0, 0x8000L);
+      case 111:
+         return jjMoveStringLiteralDfa8_0(active0, 0x100000000000L);
+      case 114:
+         return jjMoveStringLiteralDfa8_0(active0, 0x4004000L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(6, active0, 0L);
+}
+private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(6, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(7, active0, 0L);
+      return 8;
+   }
+   switch(curChar)
+   {
+      case 97:
+         return jjMoveStringLiteralDfa9_0(active0, 0x1008000L);
+      case 101:
+         if ((active0 & 0x200L) != 0L)
+            return jjStartNfaWithStates_0(8, 9, 35);
+         else if ((active0 & 0x20000L) != 0L)
+            return jjStartNfaWithStates_0(8, 17, 35);
+         return jjMoveStringLiteralDfa9_0(active0, 0x84000L);
+      case 107:
+         return jjMoveStringLiteralDfa9_0(active0, 0x342000L);
+      case 110:
+         if ((active0 & 0x100000000000L) != 0L)
+            return jjStartNfaWithStates_0(8, 44, 35);
+         break;
+      case 111:
+         return jjMoveStringLiteralDfa9_0(active0, 0x800000L);
+      case 115:
+         if ((active0 & 0x4000000L) != 0L)
+            return jjStartNfaWithStates_0(8, 26, 35);
+         return jjMoveStringLiteralDfa9_0(active0, 0x2010400L);
+      case 117:
+         return jjMoveStringLiteralDfa9_0(active0, 0x800L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(7, active0, 0L);
+}
+private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(7, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(8, active0, 0L);
+      return 9;
+   }
+   switch(curChar)
+   {
+      case 95:
+         return jjMoveStringLiteralDfa10_0(active0, 0x300000L);
+      case 97:
+         return jjMoveStringLiteralDfa10_0(active0, 0x42000L);
+      case 98:
+         return jjMoveStringLiteralDfa10_0(active0, 0x1000000L);
+      case 100:
+         return jjMoveStringLiteralDfa10_0(active0, 0x800L);
+      case 102:
+         return jjMoveStringLiteralDfa10_0(active0, 0x4000L);
+      case 109:
+         return jjMoveStringLiteralDfa10_0(active0, 0x8000L);
+      case 110:
+         return jjMoveStringLiteralDfa10_0(active0, 0x800000L);
+      case 112:
+         return jjMoveStringLiteralDfa10_0(active0, 0x2010400L);
+      case 115:
+         return jjMoveStringLiteralDfa10_0(active0, 0x80000L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(8, active0, 0L);
+}
+private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(8, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(9, active0, 0L);
+      return 10;
+   }
+   switch(curChar)
+   {
+      case 97:
+         return jjMoveStringLiteralDfa11_0(active0, 0x2810400L);
+      case 99:
+         return jjMoveStringLiteralDfa11_0(active0, 0x100000L);
+      case 101:
+         if ((active0 & 0x800L) != 0L)
+            return jjStartNfaWithStates_0(10, 11, 35);
+         return jjMoveStringLiteralDfa11_0(active0, 0x8000L);
+      case 103:
+         return jjMoveStringLiteralDfa11_0(active0, 0x42000L);
+      case 105:
+         return jjMoveStringLiteralDfa11_0(active0, 0x4000L);
+      case 108:
+         return jjMoveStringLiteralDfa11_0(active0, 0x1000000L);
+      case 112:
+         return jjMoveStringLiteralDfa11_0(active0, 0x280000L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(9, active0, 0L);
+}
+private final int jjMoveStringLiteralDfa11_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(9, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(10, active0, 0L);
+      return 11;
+   }
+   switch(curChar)
+   {
+      case 97:
+         return jjMoveStringLiteralDfa12_0(active0, 0x180000L);
+      case 99:
+         return jjMoveStringLiteralDfa12_0(active0, 0x2010400L);
+      case 101:
+         if ((active0 & 0x2000L) != 0L)
+            return jjStartNfaWithStates_0(11, 13, 35);
+         else if ((active0 & 0x40000L) != 0L)
+            return jjStartNfaWithStates_0(11, 18, 35);
+         else if ((active0 & 0x1000000L) != 0L)
+            return jjStartNfaWithStates_0(11, 24, 35);
+         break;
+      case 108:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_0(11, 23, 35);
+         break;
+      case 114:
+         return jjMoveStringLiteralDfa12_0(active0, 0x200000L);
+      case 115:
+         return jjMoveStringLiteralDfa12_0(active0, 0x8000L);
+      case 120:
+         if ((active0 & 0x4000L) != 0L)
+            return jjStartNfaWithStates_0(11, 14, 35);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_0(10, active0, 0L);
+}
+private final int jjMoveStringLiteralDfa12_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(10, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(11, active0, 0L);
+      return 12;
+   }
+   switch(curChar)
+   {
+      case 99:
+         return jjMoveStringLiteralDfa13_0(active0, 0x80000L);
+      case 101:
+         if ((active0 & 0x400L) != 0L)
+            return jjStartNfaWithStates_0(12, 10, 35);
+         else if ((active0 & 0x10000L) != 0L)
+            return jjStartNfaWithStates_0(12, 16, 35);
+         else if ((active0 & 0x2000000L) != 0L)
+            return jjStartNfaWithStates_0(12, 25, 35);
+         return jjMoveStringLiteralDfa13_0(active0, 0x200000L);
+      case 112:
+         return jjMoveStringLiteralDfa13_0(active0, 0x8000L);
+      case 116:
+         return jjMoveStringLiteralDfa13_0(active0, 0x100000L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(11, active0, 0L);
+}
+private final int jjMoveStringLiteralDfa13_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(11, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(12, active0, 0L);
+      return 13;
+   }
+   switch(curChar)
+   {
+      case 97:
+         return jjMoveStringLiteralDfa14_0(active0, 0x8000L);
+      case 101:
+         if ((active0 & 0x80000L) != 0L)
+            return jjStartNfaWithStates_0(13, 19, 35);
+         return jjMoveStringLiteralDfa14_0(active0, 0x100000L);
+      case 102:
+         return jjMoveStringLiteralDfa14_0(active0, 0x200000L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(12, active0, 0L);
+}
+private final int jjMoveStringLiteralDfa14_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(12, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(13, active0, 0L);
+      return 14;
+   }
+   switch(curChar)
+   {
+      case 99:
+         return jjMoveStringLiteralDfa15_0(active0, 0x8000L);
+      case 103:
+         return jjMoveStringLiteralDfa15_0(active0, 0x100000L);
+      case 105:
+         return jjMoveStringLiteralDfa15_0(active0, 0x200000L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(13, active0, 0L);
+}
+private final int jjMoveStringLiteralDfa15_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(13, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(14, active0, 0L);
+      return 15;
+   }
+   switch(curChar)
+   {
+      case 101:
+         if ((active0 & 0x8000L) != 0L)
+            return jjStartNfaWithStates_0(15, 15, 35);
+         break;
+      case 111:
+         return jjMoveStringLiteralDfa16_0(active0, 0x100000L);
+      case 120:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStartNfaWithStates_0(15, 21, 35);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_0(14, active0, 0L);
+}
+private final int jjMoveStringLiteralDfa16_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(14, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(15, active0, 0L);
+      return 16;
+   }
+   switch(curChar)
+   {
+      case 114:
+         return jjMoveStringLiteralDfa17_0(active0, 0x100000L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(15, active0, 0L);
+}
+private final int jjMoveStringLiteralDfa17_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(15, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(16, active0, 0L);
+      return 17;
+   }
+   switch(curChar)
+   {
+      case 121:
+         if ((active0 & 0x100000L) != 0L)
+            return jjStartNfaWithStates_0(17, 20, 35);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_0(16, active0, 0L);
+}
+private final void jjCheckNAdd(int state)
+{
+   if (jjrounds[state] != jjround)
+   {
+      jjstateSet[jjnewStateCnt++] = state;
+      jjrounds[state] = jjround;
+   }
+}
+private final void jjAddStates(int start, int end)
+{
+   do {
+      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
+   } while (start++ != end);
+}
+private final void jjCheckNAddTwoStates(int state1, int state2)
+{
+   jjCheckNAdd(state1);
+   jjCheckNAdd(state2);
+}
+private final void jjCheckNAddStates(int start, int end)
+{
+   do {
+      jjCheckNAdd(jjnextStates[start]);
+   } while (start++ != end);
+}
+private final void jjCheckNAddStates(int start)
+{
+   jjCheckNAdd(jjnextStates[start]);
+   jjCheckNAdd(jjnextStates[start + 1]);
+}
+static final long[] jjbitVec0 = {
+   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
+};
+private final int jjMoveNfa_0(int startState, int curPos)
+{
+   int[] nextStates;
+   int startsAt = 0;
+   jjnewStateCnt = 35;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int j, kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         MatchLoop: do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 35:
+                  if ((0x3ff600000000000L & l) != 0L)
+                  {
+                     if (kind > 57)
+                        kind = 57;
+                     jjCheckNAdd(15);
+                  }
+                  if ((0x3ff400000000000L & l) != 0L)
+                  {
+                     if (kind > 53)
+                        kind = 53;
+                     jjCheckNAdd(7);
+                  }
+                  break;
+               case 0:
+                  if ((0x3ff000000000000L & l) != 0L)
+                  {
+                     if (kind > 51)
+                        kind = 51;
+                     jjCheckNAdd(5);
+                  }
+                  else if ((0x280000000000L & l) != 0L)
+                     jjCheckNAddStates(0, 2);
+                  else if (curChar == 47)
+                     jjAddStates(3, 4);
+                  else if (curChar == 39)
+                     jjCheckNAddTwoStates(12, 13);
+                  else if (curChar == 34)
+                     jjCheckNAddTwoStates(9, 10);
+                  else if (curChar == 35)
+                     jjCheckNAddStates(5, 7);
+                  if (curChar == 45)
+                  {
+                     if (kind > 57)
+                        kind = 57;
+                     jjCheckNAdd(15);
+                  }
+                  break;
+               case 1:
+                  if ((0xfffffffffffffbffL & l) != 0L)
+                     jjCheckNAddStates(5, 7);
+                  break;
+               case 2:
+                  if ((0x2400L & l) != 0L && kind > 5)
+                     kind = 5;
+                  break;
+               case 3:
+                  if (curChar == 10 && kind > 5)
+                     kind = 5;
+                  break;
+               case 4:
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 3;
+                  break;
+               case 5:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 51)
+                     kind = 51;
+                  jjCheckNAdd(5);
+                  break;
+               case 7:
+                  if ((0x3ff400000000000L & l) == 0L)
+                     break;
+                  if (kind > 53)
+                     kind = 53;
+                  jjCheckNAdd(7);
+                  break;
+               case 8:
+                  if (curChar == 34)
+                     jjCheckNAddTwoStates(9, 10);
+                  break;
+               case 9:
+                  if ((0xfffffffbffffffffL & l) != 0L)
+                     jjCheckNAddTwoStates(9, 10);
+                  break;
+               case 10:
+                  if (curChar == 34 && kind > 56)
+                     kind = 56;
+                  break;
+               case 11:
+                  if (curChar == 39)
+                     jjCheckNAddTwoStates(12, 13);
+                  break;
+               case 12:
+                  if ((0xffffff7fffffffffL & l) != 0L)
+                     jjCheckNAddTwoStates(12, 13);
+                  break;
+               case 13:
+                  if (curChar == 39 && kind > 56)
+                     kind = 56;
+                  break;
+               case 14:
+                  if (curChar != 45)
+                     break;
+                  if (kind > 57)
+                     kind = 57;
+                  jjCheckNAdd(15);
+                  break;
+               case 15:
+                  if ((0x3ff600000000000L & l) == 0L)
+                     break;
+                  if (kind > 57)
+                     kind = 57;
+                  jjCheckNAdd(15);
+                  break;
+               case 16:
+                  if (curChar == 47)
+                     jjAddStates(3, 4);
+                  break;
+               case 17:
+                  if (curChar == 47)
+                     jjCheckNAddStates(8, 10);
+                  break;
+               case 18:
+                  if ((0xffffffffffffdbffL & l) != 0L)
+                     jjCheckNAddStates(8, 10);
+                  break;
+               case 19:
+                  if ((0x2400L & l) != 0L && kind > 6)
+                     kind = 6;
+                  break;
+               case 20:
+                  if (curChar == 10 && kind > 6)
+                     kind = 6;
+                  break;
+               case 21:
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 20;
+                  break;
+               case 22:
+                  if (curChar == 42)
+                     jjCheckNAddTwoStates(23, 24);
+                  break;
+               case 23:
+                  if ((0xfffffbffffffffffL & l) != 0L)
+                     jjCheckNAddTwoStates(23, 24);
+                  break;
+               case 24:
+                  if (curChar == 42)
+                     jjAddStates(11, 12);
+                  break;
+               case 25:
+                  if ((0xffff7fffffffffffL & l) != 0L)
+                     jjCheckNAddTwoStates(26, 24);
+                  break;
+               case 26:
+                  if ((0xfffffbffffffffffL & l) != 0L)
+                     jjCheckNAddTwoStates(26, 24);
+                  break;
+               case 27:
+                  if (curChar == 47 && kind > 7)
+                     kind = 7;
+                  break;
+               case 28:
+                  if ((0x280000000000L & l) != 0L)
+                     jjCheckNAddStates(0, 2);
+                  break;
+               case 29:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(29, 30);
+                  break;
+               case 30:
+                  if (curChar == 46)
+                     jjCheckNAdd(31);
+                  break;
+               case 31:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 52)
+                     kind = 52;
+                  jjCheckNAddTwoStates(31, 32);
+                  break;
+               case 33:
+                  if ((0x280000000000L & l) != 0L)
+                     jjCheckNAdd(34);
+                  break;
+               case 34:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 52)
+                     kind = 52;
+                  jjCheckNAdd(34);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         MatchLoop: do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 35:
+                  if ((0x7fffffe87fffffeL & l) != 0L)
+                  {
+                     if (kind > 57)
+                        kind = 57;
+                     jjCheckNAdd(15);
+                  }
+                  if ((0x7fffffe87fffffeL & l) != 0L)
+                  {
+                     if (kind > 53)
+                        kind = 53;
+                     jjCheckNAdd(7);
+                  }
+                  break;
+               case 0:
+                  if ((0x7fffffe07fffffeL & l) != 0L)
+                  {
+                     if (kind > 57)
+                        kind = 57;
+                     jjCheckNAdd(15);
+                  }
+                  if ((0x7fffffe07fffffeL & l) != 0L)
+                  {
+                     if (kind > 53)
+                        kind = 53;
+                     jjCheckNAdd(7);
+                  }
+                  break;
+               case 1:
+                  jjAddStates(5, 7);
+                  break;
+               case 6:
+                  if ((0x7fffffe07fffffeL & l) == 0L)
+                     break;
+                  if (kind > 53)
+                     kind = 53;
+                  jjCheckNAdd(7);
+                  break;
+               case 7:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 53)
+                     kind = 53;
+                  jjCheckNAdd(7);
+                  break;
+               case 9:
+                  jjAddStates(13, 14);
+                  break;
+               case 12:
+                  jjAddStates(15, 16);
+                  break;
+               case 14:
+                  if ((0x7fffffe07fffffeL & l) == 0L)
+                     break;
+                  if (kind > 57)
+                     kind = 57;
+                  jjCheckNAdd(15);
+                  break;
+               case 15:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 57)
+                     kind = 57;
+                  jjCheckNAdd(15);
+                  break;
+               case 18:
+                  jjAddStates(8, 10);
+                  break;
+               case 23:
+                  jjCheckNAddTwoStates(23, 24);
+                  break;
+               case 25:
+               case 26:
+                  jjCheckNAddTwoStates(26, 24);
+                  break;
+               case 32:
+                  if ((0x2000000020L & l) != 0L)
+                     jjAddStates(17, 18);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         MatchLoop: do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 1:
+                  if ((jjbitVec0[i2] & l2) != 0L)
+                     jjAddStates(5, 7);
+                  break;
+               case 9:
+                  if ((jjbitVec0[i2] & l2) != 0L)
+                     jjAddStates(13, 14);
+                  break;
+               case 12:
+                  if ((jjbitVec0[i2] & l2) != 0L)
+                     jjAddStates(15, 16);
+                  break;
+               case 18:
+                  if ((jjbitVec0[i2] & l2) != 0L)
+                     jjAddStates(8, 10);
+                  break;
+               case 23:
+                  if ((jjbitVec0[i2] & l2) != 0L)
+                     jjCheckNAddTwoStates(23, 24);
+                  break;
+               case 25:
+               case 26:
+                  if ((jjbitVec0[i2] & l2) != 0L)
+                     jjCheckNAddTwoStates(26, 24);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 35 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+static final int[] jjnextStates = {
+   5, 29, 30, 17, 22, 1, 2, 4, 18, 19, 21, 25, 27, 9, 10, 12, 
+   13, 33, 34, 
+};
+public static final String[] jjstrLiteralImages = {
+"", null, null, null, null, null, null, null, "\143\157\156\163\164", 
+"\156\141\155\145\163\160\141\143\145", "\143\160\160\137\156\141\155\145\163\160\141\143\145", 
+"\143\160\160\137\151\156\143\154\165\144\145", "\143\160\160\137\164\171\160\145", 
+"\152\141\166\141\137\160\141\143\153\141\147\145", "\143\157\143\157\141\137\160\162\145\146\151\170", 
+"\143\163\150\141\162\160\137\156\141\155\145\163\160\141\143\145", "\160\150\160\137\156\141\155\145\163\160\141\143\145", 
+"\160\171\137\155\157\144\165\154\145", "\160\145\162\154\137\160\141\143\153\141\147\145", 
+"\162\165\142\171\137\156\141\155\145\163\160\141\143\145", "\163\155\141\154\154\164\141\154\153\137\143\141\164\145\147\157\162\171", 
+"\163\155\141\154\154\164\141\154\153\137\160\162\145\146\151\170", "\170\163\144\137\141\154\154", 
+"\170\163\144\137\157\160\164\151\157\156\141\154", "\170\163\144\137\156\151\154\154\141\142\154\145", 
+"\170\163\144\137\156\141\155\145\163\160\141\143\145", "\170\163\144\137\141\164\164\162\163", "\151\156\143\154\165\144\145", 
+"\166\157\151\144", "\142\157\157\154", "\142\171\164\145", "\151\61\66", "\151\63\62", 
+"\151\66\64", "\144\157\165\142\154\145", "\163\164\162\151\156\147", 
+"\163\154\151\163\164", "\163\145\156\165\155", "\155\141\160", "\154\151\163\164", "\163\145\164", 
+"\141\163\171\156\143", "\164\171\160\145\144\145\146", "\163\164\162\165\143\164", 
+"\145\170\143\145\160\164\151\157\156", "\145\170\164\145\156\144\163", "\164\150\162\157\167\163", 
+"\163\145\162\166\151\143\145", "\145\156\165\155", "\162\145\161\165\151\162\145\144", 
+"\157\160\164\151\157\156\141\154", null, null, null, null, null, null, null, "\54", "\73", "\173", "\175", "\75", 
+"\133", "\135", "\72", "\50", "\51", "\74", "\76", };
+public static final String[] lexStateNames = {
+   "DEFAULT", 
+};
+static final long[] jjtoToken = {
+   0xff3fffffffffff01L, 0x3fL, 
+};
+static final long[] jjtoSkip = {
+   0xfeL, 0x0L, 
+};
+protected SimpleCharStream input_stream;
+private final int[] jjrounds = new int[35];
+private final int[] jjstateSet = new int[70];
+protected char curChar;
+public thrift_grammarTokenManager(SimpleCharStream stream){
+   if (SimpleCharStream.staticFlag)
+      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
+   input_stream = stream;
+}
+public thrift_grammarTokenManager(SimpleCharStream stream, int lexState){
+   this(stream);
+   SwitchTo(lexState);
+}
+public void ReInit(SimpleCharStream stream)
+{
+   jjmatchedPos = jjnewStateCnt = 0;
+   curLexState = defaultLexState;
+   input_stream = stream;
+   ReInitRounds();
+}
+private final void ReInitRounds()
+{
+   int i;
+   jjround = 0x80000001;
+   for (i = 35; i-- > 0;)
+      jjrounds[i] = 0x80000000;
+}
+public void ReInit(SimpleCharStream stream, int lexState)
+{
+   ReInit(stream);
+   SwitchTo(lexState);
+}
+public void SwitchTo(int lexState)
+{
+   if (lexState >= 1 || lexState < 0)
+      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
+   else
+      curLexState = lexState;
+}
+
+protected Token jjFillToken()
+{
+   Token t = Token.newToken(jjmatchedKind);
+   t.kind = jjmatchedKind;
+   String im = jjstrLiteralImages[jjmatchedKind];
+   t.image = (im == null) ? input_stream.GetImage() : im;
+   t.beginLine = input_stream.getBeginLine();
+   t.beginColumn = input_stream.getBeginColumn();
+   t.endLine = input_stream.getEndLine();
+   t.endColumn = input_stream.getEndColumn();
+   return t;
+}
+
+int curLexState = 0;
+int defaultLexState = 0;
+int jjnewStateCnt;
+int jjround;
+int jjmatchedPos;
+int jjmatchedKind;
+
+public Token getNextToken() 
+{
+  int kind;
+  Token specialToken = null;
+  Token matchedToken;
+  int curPos = 0;
+
+  EOFLoop :
+  for (;;)
+  {   
+   try   
+   {     
+      curChar = input_stream.BeginToken();
+   }     
+   catch(java.io.IOException e)
+   {        
+      jjmatchedKind = 0;
+      matchedToken = jjFillToken();
+      return matchedToken;
+   }
+
+   try { input_stream.backup(0);
+      while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
+         curChar = input_stream.BeginToken();
+   }
+   catch (java.io.IOException e1) { continue EOFLoop; }
+   jjmatchedKind = 0x7fffffff;
+   jjmatchedPos = 0;
+   curPos = jjMoveStringLiteralDfa0_0();
+   if (jjmatchedKind != 0x7fffffff)
+   {
+      if (jjmatchedPos + 1 < curPos)
+         input_stream.backup(curPos - jjmatchedPos - 1);
+      if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
+      {
+         matchedToken = jjFillToken();
+         return matchedToken;
+      }
+      else
+      {
+         continue EOFLoop;
+      }
+   }
+   int error_line = input_stream.getEndLine();
+   int error_column = input_stream.getEndColumn();
+   String error_after = null;
+   boolean EOFSeen = false;
+   try { input_stream.readChar(); input_stream.backup(1); }
+   catch (java.io.IOException e1) {
+      EOFSeen = true;
+      error_after = curPos <= 1 ? "" : input_stream.GetImage();
+      if (curChar == '\n' || curChar == '\r') {
+         error_line++;
+         error_column = 0;
+      }
+      else
+         error_column++;
+   }
+   if (!EOFSeen) {
+      input_stream.backup(1);
+      error_after = curPos <= 1 ? "" : input_stream.GetImage();
+   }
+   throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
+  }
+}
+
+}

Added: hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/dynamic_type/thrift_grammarTreeConstants.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/dynamic_type/thrift_grammarTreeConstants.java?rev=706704&view=auto
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/dynamic_type/thrift_grammarTreeConstants.java (added)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/dynamic_type/thrift_grammarTreeConstants.java Tue Oct 21 11:11:05 2008
@@ -0,0 +1,105 @@
+/* Generated By:JJTree: Do not edit this line. /data/users/zshao/tubbs-svnroot/projects/hadoop/trunk/VENDOR/hadoop-0.17/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/dynamic_type/thrift_grammarTreeConstants.java */
+
+package org.apache.hadoop.hive.serde2.dynamic_type;
+
+public interface thrift_grammarTreeConstants
+{
+  public int JJTSTART = 0;
+  public int JJTHEADERLIST = 1;
+  public int JJTHEADER = 2;
+  public int JJTNAMESPACE = 3;
+  public int JJTINCLUDE = 4;
+  public int JJTDEFINITION = 5;
+  public int JJTTYPEDEFINITION = 6;
+  public int JJTTYPEDEF = 7;
+  public int JJTCOMMAORSEMICOLON = 8;
+  public int JJTENUM = 9;
+  public int JJTENUMDEFLIST = 10;
+  public int JJTENUMDEF = 11;
+  public int JJTSENUM = 12;
+  public int JJTSENUMDEFLIST = 13;
+  public int JJTSENUMDEF = 14;
+  public int JJTCONST = 15;
+  public int JJTCONSTVALUE = 16;
+  public int JJTCONSTLIST = 17;
+  public int JJTCONSTLISTCONTENTS = 18;
+  public int JJTCONSTMAP = 19;
+  public int JJTCONSTMAPCONTENTS = 20;
+  public int JJTSTRUCT = 21;
+  public int JJTXCEPTION = 22;
+  public int JJTSERVICE = 23;
+  public int JJTFLAGARGS = 24;
+  public int JJTUNFLAGARGS = 25;
+  public int JJTEXTENDS = 26;
+  public int JJTFUNCTION = 27;
+  public int JJTASYNC = 28;
+  public int JJTTHROWS = 29;
+  public int JJTFIELDLIST = 30;
+  public int JJTFIELD = 31;
+  public int JJTFIELDREQUIREDNESS = 32;
+  public int JJTFIELDVALUE = 33;
+  public int JJTDEFINITIONTYPE = 34;
+  public int JJTFUNCTIONTYPE = 35;
+  public int JJTFIELDTYPE = 36;
+  public int JJTTYPESTRING = 37;
+  public int JJTTYPEBYTE = 38;
+  public int JJTTYPEI16 = 39;
+  public int JJTTYPEI32 = 40;
+  public int JJTTYPEI64 = 41;
+  public int JJTTYPEDOUBLE = 42;
+  public int JJTTYPEBOOL = 43;
+  public int JJTTYPEMAP = 44;
+  public int JJTTYPESET = 45;
+  public int JJTTYPELIST = 46;
+
+
+  public String[] jjtNodeName = {
+    "Start",
+    "HeaderList",
+    "Header",
+    "Namespace",
+    "Include",
+    "Definition",
+    "TypeDefinition",
+    "Typedef",
+    "CommaOrSemicolon",
+    "Enum",
+    "EnumDefList",
+    "EnumDef",
+    "Senum",
+    "SenumDefList",
+    "SenumDef",
+    "Const",
+    "ConstValue",
+    "ConstList",
+    "ConstListContents",
+    "ConstMap",
+    "ConstMapContents",
+    "Struct",
+    "Xception",
+    "Service",
+    "FlagArgs",
+    "UnflagArgs",
+    "Extends",
+    "Function",
+    "Async",
+    "Throws",
+    "FieldList",
+    "Field",
+    "FieldRequiredness",
+    "FieldValue",
+    "DefinitionType",
+    "FunctionType",
+    "FieldType",
+    "TypeString",
+    "TypeByte",
+    "Typei16",
+    "Typei32",
+    "Typei64",
+    "TypeDouble",
+    "TypeBool",
+    "TypeMap",
+    "TypeSet",
+    "TypeList",
+  };
+}

Added: hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/thrift/test/Complex.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/thrift/test/Complex.java?rev=706704&view=auto
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/thrift/test/Complex.java (added)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/thrift/test/Complex.java Tue Oct 21 11:11:05 2008
@@ -0,0 +1,345 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+package org.apache.hadoop.hive.serde2.thrift.test;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Set;
+import java.util.HashSet;
+import com.facebook.thrift.*;
+
+import com.facebook.thrift.protocol.*;
+import com.facebook.thrift.transport.*;
+
+public class Complex implements TBase, java.io.Serializable {
+  public int aint;
+  public String aString;
+  public List<Integer> lint;
+  public List<String> lString;
+  public List<IntString> lintString;
+  public Map<String,String> mStringString;
+
+  public final Isset __isset = new Isset();
+  public static final class Isset implements java.io.Serializable {
+    public boolean aint = false;
+    public boolean aString = false;
+    public boolean lint = false;
+    public boolean lString = false;
+    public boolean lintString = false;
+    public boolean mStringString = false;
+  }
+
+  public Complex() {
+  }
+
+  public Complex(
+    int aint,
+    String aString,
+    List<Integer> lint,
+    List<String> lString,
+    List<IntString> lintString,
+    Map<String,String> mStringString)
+  {
+    this();
+    this.aint = aint;
+    this.__isset.aint = true;
+    this.aString = aString;
+    this.__isset.aString = true;
+    this.lint = lint;
+    this.__isset.lint = true;
+    this.lString = lString;
+    this.__isset.lString = true;
+    this.lintString = lintString;
+    this.__isset.lintString = true;
+    this.mStringString = mStringString;
+    this.__isset.mStringString = true;
+  }
+
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof Complex)
+      return this.equals((Complex)that);
+    return false;
+  }
+
+  public boolean equals(Complex that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_aint = true;
+    boolean that_present_aint = true;
+    if (this_present_aint || that_present_aint) {
+      if (!(this_present_aint && that_present_aint))
+        return false;
+      if (this.aint != that.aint)
+        return false;
+    }
+
+    boolean this_present_aString = true && (this.aString != null);
+    boolean that_present_aString = true && (that.aString != null);
+    if (this_present_aString || that_present_aString) {
+      if (!(this_present_aString && that_present_aString))
+        return false;
+      if (!this.aString.equals(that.aString))
+        return false;
+    }
+
+    boolean this_present_lint = true && (this.lint != null);
+    boolean that_present_lint = true && (that.lint != null);
+    if (this_present_lint || that_present_lint) {
+      if (!(this_present_lint && that_present_lint))
+        return false;
+      if (!this.lint.equals(that.lint))
+        return false;
+    }
+
+    boolean this_present_lString = true && (this.lString != null);
+    boolean that_present_lString = true && (that.lString != null);
+    if (this_present_lString || that_present_lString) {
+      if (!(this_present_lString && that_present_lString))
+        return false;
+      if (!this.lString.equals(that.lString))
+        return false;
+    }
+
+    boolean this_present_lintString = true && (this.lintString != null);
+    boolean that_present_lintString = true && (that.lintString != null);
+    if (this_present_lintString || that_present_lintString) {
+      if (!(this_present_lintString && that_present_lintString))
+        return false;
+      if (!this.lintString.equals(that.lintString))
+        return false;
+    }
+
+    boolean this_present_mStringString = true && (this.mStringString != null);
+    boolean that_present_mStringString = true && (that.mStringString != null);
+    if (this_present_mStringString || that_present_mStringString) {
+      if (!(this_present_mStringString && that_present_mStringString))
+        return false;
+      if (!this.mStringString.equals(that.mStringString))
+        return false;
+    }
+
+    return true;
+  }
+
+  public int hashCode() {
+    return 0;
+  }
+
+  public void read(TProtocol iprot) throws TException {
+    TField field;
+    iprot.readStructBegin();
+    while (true)
+    {
+      field = iprot.readFieldBegin();
+      if (field.type == TType.STOP) { 
+        break;
+      }
+      switch (field.id)
+      {
+        case 1:
+          if (field.type == TType.I32) {
+            this.aint = iprot.readI32();
+            this.__isset.aint = true;
+          } else { 
+            TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 2:
+          if (field.type == TType.STRING) {
+            this.aString = iprot.readString();
+            this.__isset.aString = true;
+          } else { 
+            TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 3:
+          if (field.type == TType.LIST) {
+            {
+              TList _list0 = iprot.readListBegin();
+              this.lint = new ArrayList<Integer>(_list0.size);
+              for (int _i1 = 0; _i1 < _list0.size; ++_i1)
+              {
+                int _elem2 = 0;
+                _elem2 = iprot.readI32();
+                this.lint.add(_elem2);
+              }
+              iprot.readListEnd();
+            }
+            this.__isset.lint = true;
+          } else { 
+            TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 4:
+          if (field.type == TType.LIST) {
+            {
+              TList _list3 = iprot.readListBegin();
+              this.lString = new ArrayList<String>(_list3.size);
+              for (int _i4 = 0; _i4 < _list3.size; ++_i4)
+              {
+                String _elem5 = null;
+                _elem5 = iprot.readString();
+                this.lString.add(_elem5);
+              }
+              iprot.readListEnd();
+            }
+            this.__isset.lString = true;
+          } else { 
+            TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 5:
+          if (field.type == TType.LIST) {
+            {
+              TList _list6 = iprot.readListBegin();
+              this.lintString = new ArrayList<IntString>(_list6.size);
+              for (int _i7 = 0; _i7 < _list6.size; ++_i7)
+              {
+                IntString _elem8 = new IntString();
+                _elem8 = new IntString();
+                _elem8.read(iprot);
+                this.lintString.add(_elem8);
+              }
+              iprot.readListEnd();
+            }
+            this.__isset.lintString = true;
+          } else { 
+            TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 6:
+          if (field.type == TType.MAP) {
+            {
+              TMap _map9 = iprot.readMapBegin();
+              this.mStringString = new HashMap<String,String>(2*_map9.size);
+              for (int _i10 = 0; _i10 < _map9.size; ++_i10)
+              {
+                String _key11;
+                String _val12;
+                _key11 = iprot.readString();
+                _val12 = iprot.readString();
+                this.mStringString.put(_key11, _val12);
+              }
+              iprot.readMapEnd();
+            }
+            this.__isset.mStringString = true;
+          } else { 
+            TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        default:
+          TProtocolUtil.skip(iprot, field.type);
+          break;
+      }
+      iprot.readFieldEnd();
+    }
+    iprot.readStructEnd();
+  }
+
+  public void write(TProtocol oprot) throws TException {
+    TStruct struct = new TStruct("Complex");
+    oprot.writeStructBegin(struct);
+    TField field = new TField();
+    field.name = "aint";
+    field.type = TType.I32;
+    field.id = 1;
+    oprot.writeFieldBegin(field);
+    oprot.writeI32(this.aint);
+    oprot.writeFieldEnd();
+    if (this.aString != null) {
+      field.name = "aString";
+      field.type = TType.STRING;
+      field.id = 2;
+      oprot.writeFieldBegin(field);
+      oprot.writeString(this.aString);
+      oprot.writeFieldEnd();
+    }
+    if (this.lint != null) {
+      field.name = "lint";
+      field.type = TType.LIST;
+      field.id = 3;
+      oprot.writeFieldBegin(field);
+      {
+        oprot.writeListBegin(new TList(TType.I32, this.lint.size()));
+        for (int _iter13 : this.lint)        {
+          oprot.writeI32(_iter13);
+        }
+        oprot.writeListEnd();
+      }
+      oprot.writeFieldEnd();
+    }
+    if (this.lString != null) {
+      field.name = "lString";
+      field.type = TType.LIST;
+      field.id = 4;
+      oprot.writeFieldBegin(field);
+      {
+        oprot.writeListBegin(new TList(TType.STRING, this.lString.size()));
+        for (String _iter14 : this.lString)        {
+          oprot.writeString(_iter14);
+        }
+        oprot.writeListEnd();
+      }
+      oprot.writeFieldEnd();
+    }
+    if (this.lintString != null) {
+      field.name = "lintString";
+      field.type = TType.LIST;
+      field.id = 5;
+      oprot.writeFieldBegin(field);
+      {
+        oprot.writeListBegin(new TList(TType.STRUCT, this.lintString.size()));
+        for (IntString _iter15 : this.lintString)        {
+          _iter15.write(oprot);
+        }
+        oprot.writeListEnd();
+      }
+      oprot.writeFieldEnd();
+    }
+    if (this.mStringString != null) {
+      field.name = "mStringString";
+      field.type = TType.MAP;
+      field.id = 6;
+      oprot.writeFieldBegin(field);
+      {
+        oprot.writeMapBegin(new TMap(TType.STRING, TType.STRING, this.mStringString.size()));
+        for (String _iter16 : this.mStringString.keySet())        {
+          oprot.writeString(_iter16);
+          oprot.writeString(this.mStringString.get(_iter16));
+        }
+        oprot.writeMapEnd();
+      }
+      oprot.writeFieldEnd();
+    }
+    oprot.writeFieldStop();
+    oprot.writeStructEnd();
+  }
+
+  public String toString() {
+    StringBuilder sb = new StringBuilder("Complex(");
+    sb.append("aint:");
+    sb.append(this.aint);
+    sb.append(",aString:");
+    sb.append(this.aString);
+    sb.append(",lint:");
+    sb.append(this.lint);
+    sb.append(",lString:");
+    sb.append(this.lString);
+    sb.append(",lintString:");
+    sb.append(this.lintString);
+    sb.append(",mStringString:");
+    sb.append(this.mStringString);
+    sb.append(")");
+    return sb.toString();
+  }
+
+}
+

Added: hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/thrift/test/Constants.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/thrift/test/Constants.java?rev=706704&view=auto
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/thrift/test/Constants.java (added)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/thrift/test/Constants.java Tue Oct 21 11:11:05 2008
@@ -0,0 +1,18 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+package org.apache.hadoop.hive.serde2.thrift.test;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Set;
+import java.util.HashSet;
+import com.facebook.thrift.*;
+
+public class Constants {
+
+}

Added: hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/thrift/test/IntString.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/thrift/test/IntString.java?rev=706704&view=auto
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/thrift/test/IntString.java (added)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/gen-java/org/apache/hadoop/hive/serde2/thrift/test/IntString.java Tue Oct 21 11:11:05 2008
@@ -0,0 +1,149 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+package org.apache.hadoop.hive.serde2.thrift.test;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Set;
+import java.util.HashSet;
+import com.facebook.thrift.*;
+
+import com.facebook.thrift.protocol.*;
+import com.facebook.thrift.transport.*;
+
+public class IntString implements TBase, java.io.Serializable {
+  public int myint;
+  public String myString;
+
+  public final Isset __isset = new Isset();
+  public static final class Isset implements java.io.Serializable {
+    public boolean myint = false;
+    public boolean myString = false;
+  }
+
+  public IntString() {
+  }
+
+  public IntString(
+    int myint,
+    String myString)
+  {
+    this();
+    this.myint = myint;
+    this.__isset.myint = true;
+    this.myString = myString;
+    this.__isset.myString = true;
+  }
+
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof IntString)
+      return this.equals((IntString)that);
+    return false;
+  }
+
+  public boolean equals(IntString that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_myint = true;
+    boolean that_present_myint = true;
+    if (this_present_myint || that_present_myint) {
+      if (!(this_present_myint && that_present_myint))
+        return false;
+      if (this.myint != that.myint)
+        return false;
+    }
+
+    boolean this_present_myString = true && (this.myString != null);
+    boolean that_present_myString = true && (that.myString != null);
+    if (this_present_myString || that_present_myString) {
+      if (!(this_present_myString && that_present_myString))
+        return false;
+      if (!this.myString.equals(that.myString))
+        return false;
+    }
+
+    return true;
+  }
+
+  public int hashCode() {
+    return 0;
+  }
+
+  public void read(TProtocol iprot) throws TException {
+    TField field;
+    iprot.readStructBegin();
+    while (true)
+    {
+      field = iprot.readFieldBegin();
+      if (field.type == TType.STOP) { 
+        break;
+      }
+      switch (field.id)
+      {
+        case 1:
+          if (field.type == TType.I32) {
+            this.myint = iprot.readI32();
+            this.__isset.myint = true;
+          } else { 
+            TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 2:
+          if (field.type == TType.STRING) {
+            this.myString = iprot.readString();
+            this.__isset.myString = true;
+          } else { 
+            TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        default:
+          TProtocolUtil.skip(iprot, field.type);
+          break;
+      }
+      iprot.readFieldEnd();
+    }
+    iprot.readStructEnd();
+  }
+
+  public void write(TProtocol oprot) throws TException {
+    TStruct struct = new TStruct("IntString");
+    oprot.writeStructBegin(struct);
+    TField field = new TField();
+    field.name = "myint";
+    field.type = TType.I32;
+    field.id = 1;
+    oprot.writeFieldBegin(field);
+    oprot.writeI32(this.myint);
+    oprot.writeFieldEnd();
+    if (this.myString != null) {
+      field.name = "myString";
+      field.type = TType.STRING;
+      field.id = 2;
+      oprot.writeFieldBegin(field);
+      oprot.writeString(this.myString);
+      oprot.writeFieldEnd();
+    }
+    oprot.writeFieldStop();
+    oprot.writeStructEnd();
+  }
+
+  public String toString() {
+    StringBuilder sb = new StringBuilder("IntString(");
+    sb.append("myint:");
+    sb.append(this.myint);
+    sb.append(",myString:");
+    sb.append(this.myString);
+    sb.append(")");
+    return sb.toString();
+  }
+
+}
+

Added: hadoop/core/trunk/src/contrib/hive/serde/src/gen-py/org_apache_hadoop_hive_serde/__init__.py
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/gen-py/org_apache_hadoop_hive_serde/__init__.py?rev=706704&view=auto
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/gen-py/org_apache_hadoop_hive_serde/__init__.py (added)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/gen-py/org_apache_hadoop_hive_serde/__init__.py Tue Oct 21 11:11:05 2008
@@ -0,0 +1 @@
+__all__ = ['ttypes', 'constants']

Added: hadoop/core/trunk/src/contrib/hive/serde/src/gen-py/org_apache_hadoop_hive_serde/constants.py
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/gen-py/org_apache_hadoop_hive_serde/constants.py?rev=706704&view=auto
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/gen-py/org_apache_hadoop_hive_serde/constants.py (added)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/gen-py/org_apache_hadoop_hive_serde/constants.py Tue Oct 21 11:11:05 2008
@@ -0,0 +1,64 @@
+#
+# Autogenerated by Thrift
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+
+from thrift.Thrift import *
+from ttypes import *
+
+SERIALIZATION_LIB = 'serialization.lib'
+
+SERIALIZATION_CLASS = 'serialization.class'
+
+SERIALIZATION_FORMAT = 'serialization.format'
+
+SERIALIZATION_DDL = 'serialization.ddl'
+
+FIELD_DELIM = 'field.delim'
+
+COLLECTION_DELIM = 'colelction.delim'
+
+LINE_DELIM = 'line.delim'
+
+MAPKEY_DELIM = 'mapkey.delim'
+
+TINYINT_TYPE_NAME = 'tinyint'
+
+INT_TYPE_NAME = 'int'
+
+BIGINT_TYPE_NAME = 'bigint'
+
+FLOAT_TYPE_NAME = 'float'
+
+DOUBLE_TYPE_NAME = 'double'
+
+STRING_TYPE_NAME = 'string'
+
+DATE_TYPE_NAME = 'date'
+
+DATETIME_TYPE_NAME = 'datetime'
+
+TIMESTAMP_TYPE_NAME = 'timestamp'
+
+LIST_TYPE_NAME = 'array'
+
+MAP_TYPE_NAME = 'map'
+
+PrimitiveTypes = set([
+  'tinyint',
+  'int',
+  'bigint',
+  'float',
+  'double',
+  'string',
+  'date',
+  'datetime',
+  'timestamp',
+])
+
+CollectionTypes = set([
+  'array',
+  'map',
+])
+

Added: hadoop/core/trunk/src/contrib/hive/serde/src/gen-py/org_apache_hadoop_hive_serde/ttypes.py
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/gen-py/org_apache_hadoop_hive_serde/ttypes.py?rev=706704&view=auto
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/gen-py/org_apache_hadoop_hive_serde/ttypes.py (added)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/gen-py/org_apache_hadoop_hive_serde/ttypes.py Tue Oct 21 11:11:05 2008
@@ -0,0 +1,16 @@
+#
+# Autogenerated by Thrift
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+
+from thrift.Thrift import *
+
+from thrift.transport import TTransport
+from thrift.protocol import TBinaryProtocol
+try:
+  from thrift.protocol import fastbinary
+except:
+  fastbinary = None
+
+

Modified: hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/ByteStreamTypedSerDe.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/ByteStreamTypedSerDe.java?rev=706704&r1=706703&r2=706704&view=diff
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/ByteStreamTypedSerDe.java (original)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/ByteStreamTypedSerDe.java Tue Oct 21 11:11:05 2008
@@ -48,6 +48,7 @@
     bos = new ByteStream.Output();
     bis = new ByteStream.Input();
     cachedBw = new BytesWritable();
+    json_serializer = new TSerializer();
   }
 
   public Object deserialize(Writable field) throws SerDeException {

Modified: hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/ReflectionSerDeField.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/ReflectionSerDeField.java?rev=706704&r1=706703&r2=706704&view=diff
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/ReflectionSerDeField.java (original)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/ReflectionSerDeField.java Tue Oct 21 11:11:05 2008
@@ -19,6 +19,7 @@
 package org.apache.hadoop.hive.serde;
 
 import java.lang.reflect.*;
+import java.util.HashMap;
 
 /**
  * The default implementation of Hive Field based on Java Reflection.
@@ -35,6 +36,7 @@
   protected Class _valueClass;
   protected Class _keyClass;
 
+  private static HashMap<String, Field[]> cacheFields = new HashMap<String, Field[]>();
 
   public static boolean isClassPrimitive(Class c) {
     return ((c == String.class) || (c == Boolean.class) ||
@@ -46,7 +48,27 @@
   public ReflectionSerDeField(String className, String fieldName) throws SerDeException {
     try {
       _parentClass = Class.forName(className);
-      _field = _parentClass.getDeclaredField(fieldName);
+      
+      // hack for now. Get all the fields and do a case-insensitive search over them
+      //      _field = _parentClass.getDeclaredField(fieldName);
+      Field[] allFields = cacheFields.get(className);
+      if (allFields == null) {
+        allFields = _parentClass.getDeclaredFields();
+        cacheFields.put(className, allFields);
+      }
+
+      boolean found = false;
+      for (Field f: allFields) {
+        if (f.getName().equalsIgnoreCase(fieldName)) {
+          _field = f;
+          found = true;
+          break;
+        }
+      }
+
+      if (!found) 
+        throw new SerDeException("Illegal class or member:"+className+"."+fieldName);
+
       _isList = java.util.List.class.isAssignableFrom(_field.getType());
       _isMap = java.util.Map.class.isAssignableFrom(_field.getType());
       _class = _field.getType();
@@ -123,7 +145,7 @@
   }
 
   public String getName() {
-    return _field.getName();
+    return _field.getName().toLowerCase();
   }
 
 

Modified: hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/SerDe.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/SerDe.java?rev=706704&r1=706703&r2=706704&view=diff
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/SerDe.java (original)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/SerDe.java Tue Oct 21 11:11:05 2008
@@ -91,6 +91,4 @@
   public SerDeField getFieldFromExpression(SerDeField parentField, String fieldExpression)
     throws SerDeException;
 
-  public String getShortName() ;
-
 }

Modified: hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/dynamic_type/DynamicSerDe.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/dynamic_type/DynamicSerDe.java?rev=706704&r1=706703&r2=706704&view=diff
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/dynamic_type/DynamicSerDe.java (original)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/dynamic_type/DynamicSerDe.java Tue Oct 21 11:11:05 2008
@@ -42,25 +42,6 @@
   transient private TProtocol oprot_;
   transient private TProtocol iprot_;
 
-  public  String getShortName() {
-    return shortName();
-  }
-
-  public static String shortName() {
-    return "dynamic_thrift";
-  }
-
-  static {
-    StackTraceElement[] sTrace = new Exception().getStackTrace();
-    String className = sTrace[0].getClassName();
-    try {
-      SerDeUtils.registerSerDe(shortName(), Class.forName(className));
-    } catch(Exception e) {
-      throw new RuntimeException(e);
-    }
-  }
-
-
   public static final String META_TABLE_NAME = "name";
 
     static public void main(String args[]) {

Modified: hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/jute/JuteSerDe.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/jute/JuteSerDe.java?rev=706704&r1=706703&r2=706704&view=diff
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/jute/JuteSerDe.java (original)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/jute/JuteSerDe.java Tue Oct 21 11:11:05 2008
@@ -34,24 +34,6 @@
 
 public class JuteSerDe implements SerDe {
 
-  public static String shortName() {
-    return "jute";
-  }
-
-  public  String getShortName() {
-    return shortName();
-  }
-
-  static {
-    StackTraceElement[] sTrace = new Exception().getStackTrace();
-    String className = sTrace[0].getClassName();
-    try {
-      SerDeUtils.registerSerDe(shortName(), Class.forName(className));
-    } catch(Exception e) {
-      throw new RuntimeException(e);
-    }
-  }
-
   protected Class<?> type;
   private static final Log LOG = LogFactory.getLog("hive.metastore");
   public void initialize(Configuration job, Properties tbl) throws SerDeException {

Modified: hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/simple_meta/MetadataTypedColumnsetSerDe.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/simple_meta/MetadataTypedColumnsetSerDe.java?rev=706704&r1=706703&r2=706704&view=diff
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/simple_meta/MetadataTypedColumnsetSerDe.java (original)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/simple_meta/MetadataTypedColumnsetSerDe.java Tue Oct 21 11:11:05 2008
@@ -37,25 +37,6 @@
   protected TIOStreamTransport outTransport, inTransport;
   protected TProtocol outProtocol, inProtocol;
 
-  public String getShortName() {
-    return shortName();
-  }
-
-
-  public static String shortName() {
-    return "simple_meta";
-  }
-
-  static {
-    StackTraceElement[] sTrace = new Exception().getStackTrace();
-    String className = sTrace[0].getClassName();
-    try {
-      SerDeUtils.registerSerDe(shortName(), Class.forName(className));
-    } catch(Exception e) {
-      throw new RuntimeException(e);
-    }
-  }
-
   final public static String DefaultSeparator = "\001";
 
   protected boolean inStreaming;
@@ -92,7 +73,7 @@
     inTransport = new TIOStreamTransport(bis);
     outProtocol = outFactory.getProtocol(outTransport);
     inProtocol = inFactory.getProtocol(inTransport);
-    json_serializer = new TSerializer(new TJSONProtocol.Factory());
+    json_serializer = new TSerializer(new TSimpleJSONProtocol.Factory());
   }
 
   public void initialize(Configuration job, Properties tbl) throws SerDeException {

Modified: hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/thrift/ThriftByteStreamTypedSerDe.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/thrift/ThriftByteStreamTypedSerDe.java?rev=706704&r1=706703&r2=706704&view=diff
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/thrift/ThriftByteStreamTypedSerDe.java (original)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/thrift/ThriftByteStreamTypedSerDe.java Tue Oct 21 11:11:05 2008
@@ -45,31 +45,13 @@
     inTransport = new TIOStreamTransport(bis);
     outProtocol = outFactory.getProtocol(outTransport);
     inProtocol = inFactory.getProtocol(inTransport);
-    json_serializer = new TSerializer(new TJSONProtocol.Factory());
+    json_serializer = new TSerializer(new TSimpleJSONProtocol.Factory());
   }
 
   public void initialize(Configuration job, Properties tbl) throws SerDeException {
     throw new SerDeException("ThriftByteStreamTypedSerDe is still semi-abstract");
   }
 
-  public static String shortName() {
-    return "thriftbytestream";
-  }
-
-  public  String getShortName() {
-    return shortName();
-  }
-
-  static {
-    StackTraceElement[] sTrace = new Exception().getStackTrace();
-    String className = sTrace[0].getClassName();
-    try {
-      SerDeUtils.registerSerDe(shortName(), Class.forName(className));
-    } catch(Exception e) {
-      throw new RuntimeException(e);
-    }
-  }
-
   public ThriftByteStreamTypedSerDe(Class<?> argType, TProtocolFactory inFactory,
                                     TProtocolFactory outFactory) throws SerDeException {
     super(argType);

Modified: hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/thrift/ThriftSerDe.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/thrift/ThriftSerDe.java?rev=706704&r1=706703&r2=706704&view=diff
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/thrift/ThriftSerDe.java (original)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/thrift/ThriftSerDe.java Tue Oct 21 11:11:05 2008
@@ -32,24 +32,6 @@
   private ThriftByteStreamTypedSerDe tsd;
   private boolean inStreaming;
 
-  public static String shortName() {
-    return "thrift";
-  }
-
-  public  String getShortName() {
-    return shortName();
-  }
-
-  static {
-    StackTraceElement[] sTrace = new Exception().getStackTrace();
-    String className = sTrace[0].getClassName();
-    try {
-      SerDeUtils.registerSerDe(shortName(), Class.forName(className));
-    } catch(Exception e) {
-      throw new RuntimeException(e);
-    }
-  }
-
   public void initialize(Configuration job, Properties tbl) throws SerDeException {
     try {
       // both the classname and the protocol name are Table properties

Modified: hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/thrift/ThriftSerDeField.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/thrift/ThriftSerDeField.java?rev=706704&r1=706703&r2=706704&view=diff
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/thrift/ThriftSerDeField.java (original)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/thrift/ThriftSerDeField.java Tue Oct 21 11:11:05 2008
@@ -20,6 +20,7 @@
 
 import org.apache.hadoop.hive.serde.*;
 import java.lang.reflect.*;
+import java.util.HashMap;
 
 /**
  * Thrift implementation of SerDeField
@@ -32,12 +33,32 @@
   private Class issetClass;
   private Field issetField;
   private Field fieldIssetField;
+  private static HashMap<String, Field[]> cacheFields = new HashMap<String, Field[]>();
 
   public ThriftSerDeField(String className, String fieldName) throws SerDeException {
     super(className, fieldName);
     try {
       issetClass = Class.forName(className+"$Isset");
-      fieldIssetField = issetClass.getDeclaredField(fieldName);
+      //      fieldIssetField = issetClass.getDeclaredField(fieldName);
+      String name = issetClass.getName();
+      Field[] allFields = cacheFields.get(name);
+      if (allFields == null) {
+        allFields = issetClass.getDeclaredFields();
+        cacheFields.put(name, allFields);
+      }
+
+      boolean found = false;
+      for (Field f: allFields) {
+        if (f.getName().equalsIgnoreCase(fieldName)) {
+          fieldIssetField = f;
+          found = true;
+          break;
+        }
+      }
+
+      if (!found) 
+        throw new SerDeException("Not a Thrift Class?");
+
       issetField = _parentClass.getDeclaredField("__isset");
     } catch (Exception e) {
       throw (new SerDeException("Not a Thrift Class?", e));

Modified: hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/thrift/columnsetSerDe.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/thrift/columnsetSerDe.java?rev=706704&r1=706703&r2=706704&view=diff
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/thrift/columnsetSerDe.java (original)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde/thrift/columnsetSerDe.java Tue Oct 21 11:11:05 2008
@@ -18,35 +18,26 @@
 
 package org.apache.hadoop.hive.serde.thrift;
 
-import org.apache.hadoop.hive.serde.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Properties;
 
-import com.facebook.thrift.TBase;
-import com.facebook.thrift.TSerializer;
-import com.facebook.thrift.protocol.*;
 import org.apache.hadoop.conf.Configuration;
-import org.apache.hadoop.io.*;
-import java.util.*;
-import java.io.*;
+import org.apache.hadoop.hive.serde.ColumnSet;
+import org.apache.hadoop.hive.serde.ComplexSerDeField;
+import org.apache.hadoop.hive.serde.ExpressionUtils;
+import org.apache.hadoop.hive.serde.ReflectionSerDeField;
+import org.apache.hadoop.hive.serde.SerDe;
+import org.apache.hadoop.hive.serde.SerDeException;
+import org.apache.hadoop.hive.serde.SerDeField;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.io.Writable;
 
-public class columnsetSerDe  extends ThriftByteStreamTypedSerDe implements SerDe {
-
-  public  String getShortName() {
-    return shortName();
-  }
-
-  public static String shortName() {
-    return "columnset";
-  }
+import com.facebook.thrift.protocol.TBinaryProtocol;
 
-  static {
-    StackTraceElement[] sTrace = new Exception().getStackTrace();
-    String className = sTrace[0].getClassName();
-    try {
-      SerDeUtils.registerSerDe(shortName(), Class.forName(className));
-    } catch(Exception e) {
-      throw new RuntimeException(e);
-    }
-  }
+public class columnsetSerDe  extends ThriftByteStreamTypedSerDe implements SerDe {
 
   protected boolean inStreaming;
   private String separator;

Modified: hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/Deserializer.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/Deserializer.java?rev=706704&r1=706703&r2=706704&view=diff
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/Deserializer.java (original)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/Deserializer.java Tue Oct 21 11:11:05 2008
@@ -58,6 +58,4 @@
    */
   public ObjectInspector getObjectInspector() throws SerDeException;
 
-  public String getShortName();
-  
 }



Mime
View raw message