hadoop-common-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dhr...@apache.org
Subject svn commit: r712905 [37/38] - in /hadoop/core/trunk: ./ src/contrib/hive/ 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/hive/data/files/ src/co...
Date Tue, 11 Nov 2008 01:50:18 GMT
Added: hadoop/core/trunk/src/contrib/hive/serde/src/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/java/org/apache/hadoop/hive/serde2/dynamic_type/thrift_grammarTokenManager.java?rev=712905&view=auto
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/dynamic_type/thrift_grammarTokenManager.java (added)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/dynamic_type/thrift_grammarTokenManager.java Mon Nov 10 17:50:06 2008
@@ -0,0 +1,1461 @@
+/* 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 & 0xfffffffffff00L) != 0L)
+         {
+            jjmatchedKind = 54;
+            return 35;
+         }
+         return -1;
+      case 1:
+         if ((active0 & 0xfffffffffff00L) != 0L)
+         {
+            jjmatchedKind = 54;
+            jjmatchedPos = 1;
+            return 35;
+         }
+         return -1;
+      case 2:
+         if ((active0 & 0x14380000000L) != 0L)
+            return 35;
+         if ((active0 & 0xffebc7fffff00L) != 0L)
+         {
+            jjmatchedKind = 54;
+            jjmatchedPos = 2;
+            return 35;
+         }
+         return -1;
+      case 3:
+         if ((active0 & 0x9008070000000L) != 0L)
+            return 35;
+         if ((active0 & 0x6fe3c0fffff00L) != 0L)
+         {
+            jjmatchedKind = 54;
+            jjmatchedPos = 3;
+            return 35;
+         }
+         return -1;
+      case 4:
+         if ((active0 & 0x23000000100L) != 0L)
+            return 35;
+         if ((active0 & 0x6fc0c0ffffe00L) != 0L)
+         {
+            jjmatchedKind = 54;
+            jjmatchedPos = 4;
+            return 35;
+         }
+         return -1;
+      case 5:
+         if ((active0 & 0x480c00000000L) != 0L)
+            return 35;
+         if ((active0 & 0x6b4000ffffe00L) != 0L)
+         {
+            jjmatchedKind = 54;
+            jjmatchedPos = 5;
+            return 35;
+         }
+         return -1;
+      case 6:
+         if ((active0 & 0x6100007bffe00L) != 0L)
+         {
+            jjmatchedKind = 54;
+            jjmatchedPos = 6;
+            return 35;
+         }
+         if ((active0 & 0xa40008400000L) != 0L)
+            return 35;
+         return -1;
+      case 7:
+         if ((active0 & 0x100007bfee00L) != 0L)
+         {
+            jjmatchedKind = 54;
+            jjmatchedPos = 7;
+            return 35;
+         }
+         if ((active0 & 0x6000000001000L) != 0L)
+            return 35;
+         return -1;
+      case 8:
+         if ((active0 & 0x3bdec00L) != 0L)
+         {
+            jjmatchedKind = 54;
+            jjmatchedPos = 8;
+            return 35;
+         }
+         if ((active0 & 0x100004020200L) != 0L)
+            return 35;
+         return -1;
+      case 9:
+         if ((active0 & 0x3bdec00L) != 0L)
+         {
+            jjmatchedKind = 54;
+            jjmatchedPos = 9;
+            return 35;
+         }
+         return -1;
+      case 10:
+         if ((active0 & 0x800L) != 0L)
+            return 35;
+         if ((active0 & 0x3bde400L) != 0L)
+         {
+            jjmatchedKind = 54;
+            jjmatchedPos = 10;
+            return 35;
+         }
+         return -1;
+      case 11:
+         if ((active0 & 0x1846000L) != 0L)
+            return 35;
+         if ((active0 & 0x2398400L) != 0L)
+         {
+            jjmatchedKind = 54;
+            jjmatchedPos = 11;
+            return 35;
+         }
+         return -1;
+      case 12:
+         if ((active0 & 0x2010400L) != 0L)
+            return 35;
+         if ((active0 & 0x388000L) != 0L)
+         {
+            jjmatchedKind = 54;
+            jjmatchedPos = 12;
+            return 35;
+         }
+         return -1;
+      case 13:
+         if ((active0 & 0x80000L) != 0L)
+            return 35;
+         if ((active0 & 0x308000L) != 0L)
+         {
+            jjmatchedKind = 54;
+            jjmatchedPos = 13;
+            return 35;
+         }
+         return -1;
+      case 14:
+         if ((active0 & 0x308000L) != 0L)
+         {
+            jjmatchedKind = 54;
+            jjmatchedPos = 14;
+            return 35;
+         }
+         return -1;
+      case 15:
+         if ((active0 & 0x208000L) != 0L)
+            return 35;
+         if ((active0 & 0x100000L) != 0L)
+         {
+            jjmatchedKind = 54;
+            jjmatchedPos = 15;
+            return 35;
+         }
+         return -1;
+      case 16:
+         if ((active0 & 0x100000L) != 0L)
+         {
+            jjmatchedKind = 54;
+            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, 67);
+      case 41:
+         return jjStopAtPos(0, 68);
+      case 44:
+         return jjStopAtPos(0, 59);
+      case 58:
+         return jjStopAtPos(0, 66);
+      case 59:
+         return jjStopAtPos(0, 60);
+      case 60:
+         return jjStopAtPos(0, 69);
+      case 61:
+         return jjStopAtPos(0, 63);
+      case 62:
+         return jjStopAtPos(0, 70);
+      case 91:
+         return jjStopAtPos(0, 64);
+      case 93:
+         return jjStopAtPos(0, 65);
+      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(0x8893800300000L);
+      case 116:
+         return jjMoveStringLiteralDfa1_0(0x440000000000L);
+      case 118:
+         return jjMoveStringLiteralDfa1_0(0x10000000L);
+      case 120:
+         return jjMoveStringLiteralDfa1_0(0x7c00000L);
+      case 123:
+         return jjStopAtPos(0, 61);
+      case 125:
+         return jjStopAtPos(0, 62);
+      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 107:
+         return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000L);
+      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, 0x8001010000000L);
+      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 112:
+         if ((active0 & 0x8000000000000L) != 0L)
+            return jjStartNfaWithStates_0(3, 51, 35);
+         break;
+      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 > 58)
+                        kind = 58;
+                     jjCheckNAdd(15);
+                  }
+                  if ((0x3ff400000000000L & l) != 0L)
+                  {
+                     if (kind > 54)
+                        kind = 54;
+                     jjCheckNAdd(7);
+                  }
+                  break;
+               case 0:
+                  if ((0x3ff000000000000L & l) != 0L)
+                  {
+                     if (kind > 52)
+                        kind = 52;
+                     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 > 58)
+                        kind = 58;
+                     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 > 52)
+                     kind = 52;
+                  jjCheckNAdd(5);
+                  break;
+               case 7:
+                  if ((0x3ff400000000000L & l) == 0L)
+                     break;
+                  if (kind > 54)
+                     kind = 54;
+                  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 > 57)
+                     kind = 57;
+                  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 > 57)
+                     kind = 57;
+                  break;
+               case 14:
+                  if (curChar != 45)
+                     break;
+                  if (kind > 58)
+                     kind = 58;
+                  jjCheckNAdd(15);
+                  break;
+               case 15:
+                  if ((0x3ff600000000000L & l) == 0L)
+                     break;
+                  if (kind > 58)
+                     kind = 58;
+                  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 > 53)
+                     kind = 53;
+                  jjCheckNAddTwoStates(31, 32);
+                  break;
+               case 33:
+                  if ((0x280000000000L & l) != 0L)
+                     jjCheckNAdd(34);
+                  break;
+               case 34:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 53)
+                     kind = 53;
+                  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 > 58)
+                        kind = 58;
+                     jjCheckNAdd(15);
+                  }
+                  if ((0x7fffffe87fffffeL & l) != 0L)
+                  {
+                     if (kind > 54)
+                        kind = 54;
+                     jjCheckNAdd(7);
+                  }
+                  break;
+               case 0:
+                  if ((0x7fffffe07fffffeL & l) != 0L)
+                  {
+                     if (kind > 58)
+                        kind = 58;
+                     jjCheckNAdd(15);
+                  }
+                  if ((0x7fffffe07fffffeL & l) != 0L)
+                  {
+                     if (kind > 54)
+                        kind = 54;
+                     jjCheckNAdd(7);
+                  }
+                  break;
+               case 1:
+                  jjAddStates(5, 7);
+                  break;
+               case 6:
+                  if ((0x7fffffe07fffffeL & l) == 0L)
+                     break;
+                  if (kind > 54)
+                     kind = 54;
+                  jjCheckNAdd(7);
+                  break;
+               case 7:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 54)
+                     kind = 54;
+                  jjCheckNAdd(7);
+                  break;
+               case 9:
+                  jjAddStates(13, 14);
+                  break;
+               case 12:
+                  jjAddStates(15, 16);
+                  break;
+               case 14:
+                  if ((0x7fffffe07fffffeL & l) == 0L)
+                     break;
+                  if (kind > 58)
+                     kind = 58;
+                  jjCheckNAdd(15);
+                  break;
+               case 15:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 58)
+                     kind = 58;
+                  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", "\163\153\151\160", 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 = {
+   0xfe7fffffffffff01L, 0x7fL, 
+};
+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/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/java/org/apache/hadoop/hive/serde2/dynamic_type/thrift_grammarTreeConstants.java?rev=712905&view=auto
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/dynamic_type/thrift_grammarTreeConstants.java (added)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/dynamic_type/thrift_grammarTreeConstants.java Mon Nov 10 17:50:06 2008
@@ -0,0 +1,105 @@
+/* Generated By:JJTree: Do not edit this line. /home/pwyckoff/projects/hadoop/trunk/VENDOR/hadoop-0.17/src/contrib/hive/serde/src/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",
+  };
+}

Modified: hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorUtils.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorUtils.java?rev=712905&r1=712904&r2=712905&view=diff
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorUtils.java (original)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorUtils.java Mon Nov 10 17:50:06 2008
@@ -63,34 +63,32 @@
     return primitiveClass;
   }
   
+  public static final Map<Class<?>, String> classToTypeName = new HashMap<Class<?>, String>();
+  static {
+    classToTypeName.put(Boolean.class, org.apache.hadoop.hive.serde.Constants.BOOLEAN_TYPE_NAME);
+    classToTypeName.put(Byte.class, org.apache.hadoop.hive.serde.Constants.TINYINT_TYPE_NAME);
+    classToTypeName.put(Short.class, org.apache.hadoop.hive.serde.Constants.SMALLINT_TYPE_NAME);
+    classToTypeName.put(Integer.class, org.apache.hadoop.hive.serde.Constants.INT_TYPE_NAME);
+    classToTypeName.put(Long.class, org.apache.hadoop.hive.serde.Constants.BIGINT_TYPE_NAME);
+    classToTypeName.put(Float.class, org.apache.hadoop.hive.serde.Constants.FLOAT_TYPE_NAME);
+    classToTypeName.put(Double.class, org.apache.hadoop.hive.serde.Constants.DOUBLE_TYPE_NAME);
+    classToTypeName.put(String.class, org.apache.hadoop.hive.serde.Constants.STRING_TYPE_NAME);
+    classToTypeName.put(java.sql.Date.class, org.apache.hadoop.hive.serde.Constants.DATE_TYPE_NAME);
+  }
   /**
    * Get the short name for the types
    */
-  public static String getClassShortName(String className) {
-    String result = className;
-    
-    if (result.equals(String.class.getName())) {
-      result = org.apache.hadoop.hive.serde.Constants.STRING_TYPE_NAME;
-    } else if (result.equals(Integer.class.getName())) {
-      result = org.apache.hadoop.hive.serde.Constants.INT_TYPE_NAME;
-    } else if (result.equals(Float.class.getName())) {
-      result = org.apache.hadoop.hive.serde.Constants.FLOAT_TYPE_NAME;
-    } else if (result.equals(Double.class.getName())) {
-      result = org.apache.hadoop.hive.serde.Constants.DOUBLE_TYPE_NAME;
-    } else if (result.equals(Long.class.getName())) {
-      result = org.apache.hadoop.hive.serde.Constants.BIGINT_TYPE_NAME;
-    } else if (result.equals(java.sql.Date.class.getName())) {
-      result = org.apache.hadoop.hive.serde.Constants.DATE_TYPE_NAME;
-    } else {
-      LOG.warn("unsupported class: " + className);
-    }
-    
-    // Remove prefix
-    String prefix = "java.lang.";
-    if (result.startsWith(prefix)) {
-      result = result.substring(prefix.length());
+  public static String getClassShortName(Class<?> classObject) {
+    String result = classToTypeName.get(classObject);
+    if (result == null) {
+      result = classObject.getName();
+      LOG.warn("unsupported class: " + result);
+      // Remove prefix
+      String prefix = "java.lang.";
+      if (result.startsWith(prefix)) {
+        result = result.substring(prefix.length());
+      }
     }
-    
     return result;
   }
   
@@ -251,6 +249,15 @@
         return fields.get(i);
       }
     }
+    // For backward compatibility: fieldNames can also be integer Strings.
+    try {
+      int i = Integer.parseInt(fieldName);
+      if (i>=0 && i<fields.size()) {
+        return fields.get(i);
+      }
+    } catch (NumberFormatException e) {
+      // ignore
+    }
     throw new RuntimeException("cannot find field " + fieldName + " from " + fields); 
     // return null;
   }

Modified: hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/StandardPrimitiveObjectInspector.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/StandardPrimitiveObjectInspector.java?rev=712905&r1=712904&r2=712905&view=diff
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/StandardPrimitiveObjectInspector.java (original)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/StandardPrimitiveObjectInspector.java Mon Nov 10 17:50:06 2008
@@ -43,7 +43,7 @@
   }
 
   public String getTypeName() {
-    return ObjectInspectorUtils.getClassShortName(primitiveClass.getName());
+    return ObjectInspectorUtils.getClassShortName(primitiveClass);
   }
 
 }

Added: hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/thrift/SkippableTProtocol.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/thrift/SkippableTProtocol.java?rev=712905&view=auto
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/thrift/SkippableTProtocol.java (added)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/thrift/SkippableTProtocol.java Mon Nov 10 17:50:06 2008
@@ -0,0 +1,29 @@
+/**
+ * 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.hive.serde2.thrift;
+
+import com.facebook.thrift.TException;
+
+/**
+ * An interface for TProtocols that can efficiently skip fields when
+ * deserializing.
+ */
+public interface SkippableTProtocol {
+  public void skip(byte type) throws TException;
+}

Added: hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/thrift/TBinarySortableProtocol.java
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/thrift/TBinarySortableProtocol.java?rev=712905&view=auto
==============================================================================
--- hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/thrift/TBinarySortableProtocol.java (added)
+++ hadoop/core/trunk/src/contrib/hive/serde/src/java/org/apache/hadoop/hive/serde2/thrift/TBinarySortableProtocol.java Mon Nov 10 17:50:06 2008
@@ -0,0 +1,547 @@
+/**
+ * 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.hive.serde2.thrift;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import com.facebook.thrift.TException;
+import com.facebook.thrift.transport.*;
+import com.facebook.thrift.protocol.*;
+import java.util.*;
+import java.io.*;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hive.serde.Constants;
+
+import java.util.Properties;
+
+/**
+ * An implementation of the Thrift Protocol for binary sortable records.
+ * 
+ * The data format:
+ * NULL:  a single byte \0
+ * NON-NULL Primitives: ALWAYS prepend a single byte \1, and then:
+ *   Boolean: FALSE = \1, TRUE = \2
+ *   Byte:    flip the sign-bit to make sure negative comes before positive
+ *   Short:   flip the sign-bit to make sure negative comes before positive
+ *   Int:     flip the sign-bit to make sure negative comes before positive
+ *   Long:    flip the sign-bit to make sure negative comes before positive
+ *   Double:  flip the sign-bit for positive double, and all bits for negative double values
+ *   String:  NULL-terminated string
+ * NON-NULL Complex Types:
+ *   Struct:  first the single byte \1, and then one field by one field.
+ *   List:    size stored as Int (see above), then one element by one element. 
+ *   Map:     size stored as Int (see above), then one key by one value, and then the next pair and so on.
+ *   Binary:  size stored as Int (see above), then the binary data in its original form
+ *   
+ * Note that the relative order of list/map/binary will be based on the size first (and elements one by one if 
+ * the sizes are equal). 
+ * 
+ * This protocol takes an additional parameter SERIALIZATION_SORT_ORDER which is a string containing only "+" and "-".
+ * The length of the string should equal to the number of fields in the top-level struct for serialization.
+ * "+" means the field should be sorted ascendingly, and "-" means descendingly. The sub fields in the same top-level
+ * field will have the same sort order. 
+ * 
+ * This is not thrift compliant in that it doesn't write out field ids
+ * so things cannot actually be versioned.
+ */
+public class TBinarySortableProtocol extends TProtocol implements ConfigurableTProtocol, WriteNullsProtocol {
+
+  final static Log LOG = LogFactory.getLog(TBinarySortableProtocol.class.getName());
+  
+  /**
+   * Factory for TBinarySortableProtocol objects
+   */
+  public static class Factory implements TProtocolFactory {
+
+    public TProtocol getProtocol(TTransport trans) {
+      return new TBinarySortableProtocol(trans);
+    }
+  }
+
+  public TBinarySortableProtocol(TTransport trans) {
+    super(trans);
+    stackLevel = 0;
+  }
+
+  /**
+   * The stack level of the current field.  Top-level fields have a stackLevel value of 1.
+   * Each nested struct/list/map will increase the stackLevel value by 1.
+   */
+  int stackLevel;
+  /**
+   * The field ID in the top level struct.  This is used to determine whether this field
+   * should be sorted ascendingly or descendingly.  
+   */
+  int topLevelStructFieldID;
+  /**
+   * A string that consists of only "+" and "-".  It should have the same length as the number
+   * of fields in the top level struct. "+" means the corresponding field is sorted ascendingly
+   * and "-" means the corresponding field is sorted descendingly.
+   */
+  String sortOrder;
+  /**
+   * Whether the current field is sorted ascendingly.  Always equals to
+   * sortOrder.charAt(topLevelStructFieldID) != '-'
+   */
+  boolean ascending; 
+  
+  @Override
+  public void initialize(Configuration conf, Properties tbl) throws TException {
+    sortOrder = tbl.getProperty(Constants.SERIALIZATION_SORT_ORDER);
+    if (sortOrder == null) {
+      sortOrder = "";
+    }
+    for(int i=0; i<sortOrder.length(); i++) {
+      char c = sortOrder.charAt(i); 
+      if (c != '+' && c != '-') {
+        throw new TException(Constants.SERIALIZATION_SORT_ORDER + " should be a string consists of only '+' and '-'!");
+      }
+    }
+    LOG.info("Sort order is \"" + sortOrder + "\"");
+  }
+
+  public void writeMessageBegin(TMessage message) throws TException {
+  }
+
+  public void writeMessageEnd() throws TException {
+  }
+
+  public void writeStructBegin(TStruct struct) throws TException {
+    stackLevel++;
+    if (stackLevel == 1) {
+      topLevelStructFieldID = 0;
+      ascending = (topLevelStructFieldID >= sortOrder.length() || sortOrder.charAt(topLevelStructFieldID) != '-'); 
+    } else {
+      writeRawBytes(nonNullByte, 0, 1);
+      // If the struct is null and level > 1, DynamicSerDe will call writeNull();
+    }    
+  }
+
+  public void writeStructEnd() throws TException {
+    stackLevel --;
+  }
+
+  public void writeFieldBegin(TField field) throws TException {
+  }
+
+  public void writeFieldEnd() throws TException {
+    if (stackLevel == 1) {
+      topLevelStructFieldID ++;
+      ascending = (topLevelStructFieldID >= sortOrder.length() || sortOrder.charAt(topLevelStructFieldID) != '-'); 
+    }
+  }
+
+  public void writeFieldStop() {
+  }
+
+  public void writeMapBegin(TMap map) throws TException {
+    stackLevel++;
+    if (map == null) {
+      writeRawBytes(nonNullByte, 0, 1);
+    } else {
+      writeI32(map.size);
+    }
+  }
+
+  public void writeMapEnd() throws TException {
+    stackLevel --;
+  }
+
+  public void writeListBegin(TList list) throws TException {
+    stackLevel++;
+    if (list == null) {
+      writeRawBytes(nonNullByte, 0, 1);
+    } else {
+      writeI32(list.size);
+    }
+  }
+
+  public void writeListEnd() throws TException {
+    stackLevel --;
+  }
+  
+  public void writeSetBegin(TSet set) throws TException {
+    stackLevel++;
+    if (set == null) {
+      writeRawBytes(nonNullByte, 0, 1);
+    } else {
+      writeI32(set.size);
+    }
+  }
+
+  public void writeSetEnd() throws TException {
+    stackLevel --;
+  }
+
+  byte[] rawBytesBuffer;
+  // This method takes care of bit-flipping for descending order
+  // Declare this method as final for performance reasons
+  final private void writeRawBytes(byte[] bytes, int begin, int length) throws TException {
+    if (ascending) {
+      trans_.write(bytes, begin, length);
+    } else {
+      // For fields in descending order, do a bit flip first.
+      if (rawBytesBuffer == null || rawBytesBuffer.length < bytes.length) {
+        rawBytesBuffer = new byte[bytes.length];
+      }
+      for(int i=begin; i<begin+length; i++) {
+        rawBytesBuffer[i] = (byte)(~bytes[i]);
+      }
+      trans_.write(rawBytesBuffer, begin, length);
+    }
+  }
+  
+  private byte [] bout = new byte[1];
+  public void writeBool(boolean b) throws TException {
+    bout[0] = (b ? (byte)2 : (byte)1); 
+    writeRawBytes(bout, 0, 1);
+  }
+
+  public void writeByte(byte b) throws TException {
+    writeRawBytes(nonNullByte, 0, 1);
+    // Make sure negative numbers comes before positive numbers 
+    bout[0] = (byte) (b ^ 0x80); 
+    writeRawBytes(bout, 0, 1);
+  }
+
+  private byte[] i16out = new byte[2];
+  public void writeI16(short i16) throws TException {
+    i16out[0] = (byte)(0xff & ((i16 >> 8) ^ 0x80));
+    i16out[1] = (byte)(0xff & (i16));
+    writeRawBytes(nonNullByte, 0, 1);
+    writeRawBytes(i16out, 0, 2);
+  }
+
+  private byte[] i32out = new byte[4];
+  public void writeI32(int i32) throws TException {
+    i32out[0] = (byte)(0xff & ((i32 >> 24) ^ 0x80));
+    i32out[1] = (byte)(0xff & (i32 >> 16));
+    i32out[2] = (byte)(0xff & (i32 >> 8));
+    i32out[3] = (byte)(0xff & (i32));
+    writeRawBytes(nonNullByte, 0, 1);
+    writeRawBytes(i32out, 0, 4);
+  }
+
+  private byte[] i64out = new byte[8];
+  public void writeI64(long i64) throws TException {
+    i64out[0] = (byte)(0xff & ((i64 >> 56) ^ 0x80));
+    i64out[1] = (byte)(0xff & (i64 >> 48));
+    i64out[2] = (byte)(0xff & (i64 >> 40));
+    i64out[3] = (byte)(0xff & (i64 >> 32));
+    i64out[4] = (byte)(0xff & (i64 >> 24));
+    i64out[5] = (byte)(0xff & (i64 >> 16));
+    i64out[6] = (byte)(0xff & (i64 >> 8));
+    i64out[7] = (byte)(0xff & (i64));
+    writeRawBytes(nonNullByte, 0, 1);
+    writeRawBytes(i64out, 0, 8);
+  }
+
+  public void writeDouble(double dub) throws TException {
+    long i64 = Double.doubleToLongBits(dub);
+    if ((i64 & (1L << 63)) != 0) {
+      // negative numbers, flip all bits
+      i64out[0] = (byte)(0xff & ((i64 >> 56) ^ 0xff));
+      i64out[1] = (byte)(0xff & ((i64 >> 48) ^ 0xff));
+      i64out[2] = (byte)(0xff & ((i64 >> 40) ^ 0xff));
+      i64out[3] = (byte)(0xff & ((i64 >> 32) ^ 0xff));
+      i64out[4] = (byte)(0xff & ((i64 >> 24) ^ 0xff));
+      i64out[5] = (byte)(0xff & ((i64 >> 16) ^ 0xff));
+      i64out[6] = (byte)(0xff & ((i64 >> 8) ^ 0xff));
+      i64out[7] = (byte)(0xff & ((i64) ^ 0xff));
+    } else {
+      // positive numbers, flip just the first bit
+      i64out[0] = (byte)(0xff & ((i64 >> 56) ^ 0x80));
+      i64out[1] = (byte)(0xff & (i64 >> 48));
+      i64out[2] = (byte)(0xff & (i64 >> 40));
+      i64out[3] = (byte)(0xff & (i64 >> 32));
+      i64out[4] = (byte)(0xff & (i64 >> 24));
+      i64out[5] = (byte)(0xff & (i64 >> 16));
+      i64out[6] = (byte)(0xff & (i64 >> 8));
+      i64out[7] = (byte)(0xff & (i64));
+    }
+    writeRawBytes(nonNullByte, 0, 1);
+    writeRawBytes(i64out, 0, 8);
+  }
+
+  final protected byte[] nullByte = new byte[] {0};
+  final protected byte[] nonNullByte = new byte[] {1};
+  public void writeString(String str) throws TException {
+    byte[] dat;
+    try {
+      dat = str.getBytes("UTF-8");
+    } catch (UnsupportedEncodingException uex) {
+      throw new TException("JVM DOES NOT SUPPORT UTF-8: " + uex.getMessage());
+    }
+    for(int i=0; i<str.length(); i++) {
+      if (str.charAt(i) == '\0') {
+        throw new TException( getClass().getName() + " does not support serializing strings with null bytes!");
+      }
+    }
+    writeRawBytes(nonNullByte, 0, 1);
+    writeRawBytes(dat, 0, dat.length);
+    writeRawBytes(nullByte, 0, 1);
+  }
+
+  public void writeBinary(byte[] bin) throws TException {
+    if (bin == null) {
+      writeRawBytes(nullByte, 0, 1);
+    } else {
+      writeI32(bin.length);
+      writeRawBytes(bin, 0, bin.length);
+    }
+  }
+
+  public TMessage readMessageBegin() throws TException {
+    return new TMessage(); 
+  }
+
+  public void readMessageEnd() throws TException {
+  }
+
+  TStruct tstruct = new TStruct();
+  public TStruct readStructBegin() throws TException {
+    stackLevel++;
+    if (stackLevel == 1) {
+      topLevelStructFieldID = 0;
+      ascending = (topLevelStructFieldID >= sortOrder.length() || sortOrder.charAt(topLevelStructFieldID) != '-'); 
+    } else {
+      // is this a null?
+      // only read the is-null byte for level > 1 because the top-level struct can never be null.
+      if (readIsNull()) return null;
+    }
+    return tstruct;
+  }
+
+  public void readStructEnd() throws TException {
+    stackLevel --;
+  }
+
+  TField f = new TField();
+  public TField readFieldBegin() throws TException {
+    // slight hack to communicate to DynamicSerDe that the field ids are not being set but things are ordered.
+    f.type = -1;
+    return  f;
+  }
+
+  public void readFieldEnd() throws TException {
+    if (stackLevel == 1) {
+      topLevelStructFieldID ++;
+      ascending = (topLevelStructFieldID >= sortOrder.length() || sortOrder.charAt(topLevelStructFieldID) != '-'); 
+    }
+  }
+
+  private TMap tmap = new TMap();
+  /**
+   * This method always return the same instance of TMap to avoid creating new instances.
+   * It is the responsibility of the caller to read the value before calling this method again.
+   */
+  public TMap readMapBegin() throws TException {
+    stackLevel ++;
+    tmap.size = readI32();
+    if (tmap.size == 0 && lastPrimitiveWasNull()) {
+      return null;
+    }
+    return tmap;
+  }
+
+  public void readMapEnd() throws TException {
+    stackLevel --;
+  }
+
+  private TList tlist = new TList();
+  /**
+   * This method always return the same instance of TList to avoid creating new instances.
+   * It is the responsibility of the caller to read the value before calling this method again.
+   */
+  public TList readListBegin() throws TException {
+    stackLevel ++;
+    tlist.size = readI32();
+    if (tlist.size == 0 && lastPrimitiveWasNull()) {
+      return null;
+    }    
+    return tlist;
+  }
+
+  public void readListEnd() throws TException {
+    stackLevel --;
+  }
+
+  private TSet set = new TSet();
+  /**
+   * This method always return the same instance of TSet to avoid creating new instances.
+   * It is the responsibility of the caller to read the value before calling this method again.
+   */
+  public TSet readSetBegin() throws TException {
+    stackLevel ++;
+    set.size = readI32();
+    if (set.size == 0 && lastPrimitiveWasNull()) {
+      return null;
+    }    
+    return set;
+  }
+
+  public void readSetEnd() throws TException {
+    stackLevel --;
+  }
+  
+  // This method takes care of bit-flipping for descending order
+  // Make this method final to improve performance. 
+  final private int readRawAll(byte[] buf, int off, int len) throws TException {
+    int bytes = trans_.readAll(buf, off, len);
+    if (!ascending) {
+      for(int i=off; i<off+bytes; i++) {
+        buf[i] = (byte)~buf[i];
+      }
+    }
+    return bytes;
+  }
+
+  public boolean readBool() throws TException {
+    readRawAll(bin, 0, 1);
+    lastPrimitiveWasNull = (bin[0] == 0);
+    return lastPrimitiveWasNull ? false : bin[0] == 2;
+  }
+
+  private byte[] wasNull = new byte[1];
+  final public boolean readIsNull() throws TException { 
+    readRawAll(wasNull, 0, 1);
+    lastPrimitiveWasNull = (wasNull[0] == 0);
+    return lastPrimitiveWasNull;
+  }
+  
+  private byte[] bin = new byte[1];
+  public byte readByte() throws TException {
+    if (readIsNull()) return 0;
+    readRawAll(bin, 0, 1);
+    return (byte)(bin[0] ^ 0x80);
+  }
+
+  private byte[] i16rd = new byte[2];
+  public short readI16() throws TException {
+    if (readIsNull()) return 0;
+    readRawAll(i16rd, 0, 2);
+    return
+      (short)
+      ((((i16rd[0]^0x80) & 0xff) << 8) |
+       ((i16rd[1] & 0xff)));
+  }
+
+  private byte[] i32rd = new byte[4];
+  public int readI32() throws TException {
+    if (readIsNull()) return 0;
+    readRawAll(i32rd, 0, 4);
+    return
+      (((i32rd[0]^0x80) & 0xff) << 24) |
+      ((i32rd[1] & 0xff) << 16) |
+      ((i32rd[2] & 0xff) <<  8) |
+      ((i32rd[3] & 0xff));
+  }
+
+  private byte[] i64rd = new byte[8];
+  public long readI64() throws TException {
+    if (readIsNull()) return 0;
+    readRawAll(i64rd, 0, 8);
+    return
+      ((long)((i64rd[0]^0x80) & 0xff) << 56) |
+      ((long)(i64rd[1] & 0xff) << 48) |
+      ((long)(i64rd[2] & 0xff) << 40) |
+      ((long)(i64rd[3] & 0xff) << 32) |
+      ((long)(i64rd[4] & 0xff) << 24) |
+      ((long)(i64rd[5] & 0xff) << 16) |
+      ((long)(i64rd[6] & 0xff) <<  8) |
+      ((long)(i64rd[7] & 0xff));
+  }
+
+  public double readDouble() throws TException {
+    if (readIsNull()) return 0;
+    readRawAll(i64rd, 0, 8);
+    long v = 0;
+    if ((i64rd[0] & 0x80) != 0) {
+      // Positive number
+      v = ((long)((i64rd[0]^0x80) & 0xff) << 56) |
+        ((long)(i64rd[1] & 0xff) << 48) |
+        ((long)(i64rd[2] & 0xff) << 40) |
+        ((long)(i64rd[3] & 0xff) << 32) |
+        ((long)(i64rd[4] & 0xff) << 24) |
+        ((long)(i64rd[5] & 0xff) << 16) |
+        ((long)(i64rd[6] & 0xff) <<  8) |
+        ((long)(i64rd[7] & 0xff));
+    } else {
+      // Negative number
+      v = ((long)((i64rd[0]^0xff) & 0xff) << 56) |
+        ((long)((i64rd[1]^0xff) & 0xff) << 48) |
+        ((long)((i64rd[2]^0xff) & 0xff) << 40) |
+        ((long)((i64rd[3]^0xff) & 0xff) << 32) |
+        ((long)((i64rd[4]^0xff) & 0xff) << 24) |
+        ((long)((i64rd[5]^0xff) & 0xff) << 16) |
+        ((long)((i64rd[6]^0xff) & 0xff) <<  8) |
+        ((long)((i64rd[7]^0xff) & 0xff));
+    }
+    return Double.longBitsToDouble(v);
+  }
+
+  private byte[] stringBytes = new byte[1000];
+  public String readString() throws TException {
+    if (readIsNull()) {
+      return null;
+    }
+    int i = 0;
+    while (true) {
+      readRawAll(bin, 0, 1);
+      if (bin[0] == 0) {
+        break;
+      } else {
+        if (i == stringBytes.length) {
+          stringBytes = Arrays.copyOf(stringBytes, stringBytes.length*2);
+        }
+        stringBytes[i] = bin[0];
+        i++;
+      }
+    }
+    try {
+      String r = new String(stringBytes, 0, i, "UTF-8");
+      return r;
+    } catch (UnsupportedEncodingException uex) {
+      throw new TException("JVM DOES NOT SUPPORT UTF-8: " + uex.getMessage());
+    }
+  }
+
+  public byte[] readBinary() throws TException {
+    int size = readI32();
+    if (lastPrimitiveWasNull) return null;
+    byte[] buf = new byte[size];
+    readRawAll(buf, 0, size);
+    return buf;
+  }
+
+  boolean lastPrimitiveWasNull;
+  @Override
+  public boolean lastPrimitiveWasNull() throws TException {
+    return lastPrimitiveWasNull;
+  }
+
+  @Override
+  public void writeNull() throws TException {
+    writeRawBytes(nullByte, 0, 1);
+  }
+  
+}



Mime
View raw message