FileDocCategorySizeDatePackage
ContentTypeParserTokenManager.javaAPI DocAndroid 1.5 API24295Wed May 06 22:42:46 BST 2009org.apache.james.mime4j.field.contenttype.parser

ContentTypeParserTokenManager

public class ContentTypeParserTokenManager extends Object implements ContentTypeParserConstants

Fields Summary
static int
commentNest
public PrintStream
debugStream
static final long[]
jjbitVec0
static final int[]
jjnextStates
public static final String[]
jjstrLiteralImages
public static final String[]
lexStateNames
public static final int[]
jjnewLexState
static final long[]
jjtoToken
static final long[]
jjtoSkip
static final long[]
jjtoSpecial
static final long[]
jjtoMore
protected SimpleCharStream
input_stream
private final int[]
jjrounds
private final int[]
jjstateSet
StringBuffer
image
int
jjimageLen
int
lengthOfMatch
protected char
curChar
int
curLexState
int
defaultLexState
int
jjnewStateCnt
int
jjround
int
jjmatchedPos
int
jjmatchedKind
Constructors Summary
public ContentTypeParserTokenManager(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 ContentTypeParserTokenManager(SimpleCharStream stream, int lexState)

   this(stream);
   SwitchTo(lexState);
Methods Summary
voidMoreLexicalActions()

   jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
   switch(jjmatchedKind)
   {
      case 9 :
         if (image == null)
            image = new StringBuffer();
         image.append(input_stream.GetSuffix(jjimageLen));
         jjimageLen = 0;
                          image.deleteCharAt(image.length() - 2);
         break;
      case 10 :
         if (image == null)
            image = new StringBuffer();
         image.append(input_stream.GetSuffix(jjimageLen));
         jjimageLen = 0;
              commentNest = 1;
         break;
      case 12 :
         if (image == null)
            image = new StringBuffer();
         image.append(input_stream.GetSuffix(jjimageLen));
         jjimageLen = 0;
                          image.deleteCharAt(image.length() - 2);
         break;
      case 13 :
         if (image == null)
            image = new StringBuffer();
         image.append(input_stream.GetSuffix(jjimageLen));
         jjimageLen = 0;
              ++commentNest;
         break;
      case 14 :
         if (image == null)
            image = new StringBuffer();
         image.append(input_stream.GetSuffix(jjimageLen));
         jjimageLen = 0;
              --commentNest; if (commentNest == 0) SwitchTo(INCOMMENT);
         break;
      case 16 :
         if (image == null)
            image = new StringBuffer();
         image.append(input_stream.GetSuffix(jjimageLen));
         jjimageLen = 0;
               image.deleteCharAt(image.length() - 1);
         break;
      case 17 :
         if (image == null)
            image = new StringBuffer();
         image.append(input_stream.GetSuffix(jjimageLen));
         jjimageLen = 0;
                          image.deleteCharAt(image.length() - 2);
         break;
      default : 
         break;
   }
public voidReInit(SimpleCharStream stream)

   jjmatchedPos = jjnewStateCnt = 0;
   curLexState = defaultLexState;
   input_stream = stream;
   ReInitRounds();
public voidReInit(SimpleCharStream stream, int lexState)

   ReInit(stream);
   SwitchTo(lexState);
private final voidReInitRounds()

   int i;
   jjround = 0x80000001;
   for (i = 3; i-- > 0;)
      jjrounds[i] = 0x80000000;
public voidSwitchTo(int lexState)

   if (lexState >= 4 || lexState < 0)
      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
   else
      curLexState = lexState;
voidTokenLexicalActions(Token matchedToken)

   switch(jjmatchedKind)
   {
      case 19 :
        if (image == null)
            image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                                 matchedToken.image = image.substring(0, image.length() - 1);
         break;
      default : 
         break;
   }
public TokengetNextToken()


   

  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();
      matchedToken.specialToken = specialToken;
      return matchedToken;
   }
   image = null;
   jjimageLen = 0;

   for (;;)
   {
     switch(curLexState)
     {
       case 0:
         jjmatchedKind = 0x7fffffff;
         jjmatchedPos = 0;
         curPos = jjMoveStringLiteralDfa0_0();
         break;
       case 1:
         jjmatchedKind = 0x7fffffff;
         jjmatchedPos = 0;
         curPos = jjMoveStringLiteralDfa0_1();
         break;
       case 2:
         jjmatchedKind = 0x7fffffff;
         jjmatchedPos = 0;
         curPos = jjMoveStringLiteralDfa0_2();
         break;
       case 3:
         jjmatchedKind = 0x7fffffff;
         jjmatchedPos = 0;
         curPos = jjMoveStringLiteralDfa0_3();
         break;
     }
     if (jjmatchedKind != 0x7fffffff)
     {
        if (jjmatchedPos + 1 < curPos)
           input_stream.backup(curPos - jjmatchedPos - 1);
        if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
        {
           matchedToken = jjFillToken();
           matchedToken.specialToken = specialToken;
           TokenLexicalActions(matchedToken);
       if (jjnewLexState[jjmatchedKind] != -1)
         curLexState = jjnewLexState[jjmatchedKind];
           return matchedToken;
        }
        else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
        {
           if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
           {
              matchedToken = jjFillToken();
              if (specialToken == null)
                 specialToken = matchedToken;
              else
              {
                 matchedToken.specialToken = specialToken;
                 specialToken = (specialToken.next = matchedToken);
              }
           }
         if (jjnewLexState[jjmatchedKind] != -1)
           curLexState = jjnewLexState[jjmatchedKind];
           continue EOFLoop;
        }
        MoreLexicalActions();
      if (jjnewLexState[jjmatchedKind] != -1)
        curLexState = jjnewLexState[jjmatchedKind];
        curPos = 0;
        jjmatchedKind = 0x7fffffff;
        try {
           curChar = input_stream.readChar();
           continue;
        }
        catch (java.io.IOException e1) { }
     }
     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);
   }
  }
private final voidjjAddStates(int start, int end)

   do {
      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
   } while (start++ != end);
private final voidjjCheckNAdd(int state)

   if (jjrounds[state] != jjround)
   {
      jjstateSet[jjnewStateCnt++] = state;
      jjrounds[state] = jjround;
   }
private final voidjjCheckNAddStates(int start, int end)

   do {
      jjCheckNAdd(jjnextStates[start]);
   } while (start++ != end);
private final voidjjCheckNAddStates(int start)

   jjCheckNAdd(jjnextStates[start]);
   jjCheckNAdd(jjnextStates[start + 1]);
private final voidjjCheckNAddTwoStates(int state1, int state2)

   jjCheckNAdd(state1);
   jjCheckNAdd(state2);
protected TokenjjFillToken()

   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;
private final intjjMoveNfa_0(int startState, int curPos)

      

   int[] nextStates;
   int startsAt = 0;
   jjnewStateCnt = 3;
   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 3:
                  if ((0x3ff6cfafffffdffL & l) != 0L)
                  {
                     if (kind > 21)
                        kind = 21;
                     jjCheckNAdd(2);
                  }
                  else if ((0x100000200L & l) != 0L)
                  {
                     if (kind > 6)
                        kind = 6;
                     jjCheckNAdd(0);
                  }
                  if ((0x3ff000000000000L & l) != 0L)
                  {
                     if (kind > 20)
                        kind = 20;
                     jjCheckNAdd(1);
                  }
                  break;
               case 0:
                  if ((0x100000200L & l) == 0L)
                     break;
                  kind = 6;
                  jjCheckNAdd(0);
                  break;
               case 1:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 20)
                     kind = 20;
                  jjCheckNAdd(1);
                  break;
               case 2:
                  if ((0x3ff6cfafffffdffL & l) == 0L)
                     break;
                  if (kind > 21)
                     kind = 21;
                  jjCheckNAdd(2);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else if (curChar < 128)
      {
         long l = 1L << (curChar & 077);
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 3:
               case 2:
                  if ((0xffffffffc7fffffeL & l) == 0L)
                     break;
                  kind = 21;
                  jjCheckNAdd(2);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 3:
               case 2:
                  if ((jjbitVec0[i2] & l2) == 0L)
                     break;
                  if (kind > 21)
                     kind = 21;
                  jjCheckNAdd(2);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
         return curPos;
      try { curChar = input_stream.readChar(); }
      catch(java.io.IOException e) { return curPos; }
   }
private final intjjMoveNfa_1(int startState, int curPos)

   int[] nextStates;
   int startsAt = 0;
   jjnewStateCnt = 3;
   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 0:
                  if (kind > 11)
                     kind = 11;
                  break;
               case 1:
                  if (kind > 9)
                     kind = 9;
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else if (curChar < 128)
      {
         long l = 1L << (curChar & 077);
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 0:
                  if (kind > 11)
                     kind = 11;
                  if (curChar == 92)
                     jjstateSet[jjnewStateCnt++] = 1;
                  break;
               case 1:
                  if (kind > 9)
                     kind = 9;
                  break;
               case 2:
                  if (kind > 11)
                     kind = 11;
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 0:
                  if ((jjbitVec0[i2] & l2) != 0L && kind > 11)
                     kind = 11;
                  break;
               case 1:
                  if ((jjbitVec0[i2] & l2) != 0L && kind > 9)
                     kind = 9;
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
         return curPos;
      try { curChar = input_stream.readChar(); }
      catch(java.io.IOException e) { return curPos; }
   }
private final intjjMoveNfa_2(int startState, int curPos)

   int[] nextStates;
   int startsAt = 0;
   jjnewStateCnt = 3;
   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 0:
                  if (kind > 15)
                     kind = 15;
                  break;
               case 1:
                  if (kind > 12)
                     kind = 12;
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else if (curChar < 128)
      {
         long l = 1L << (curChar & 077);
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 0:
                  if (kind > 15)
                     kind = 15;
                  if (curChar == 92)
                     jjstateSet[jjnewStateCnt++] = 1;
                  break;
               case 1:
                  if (kind > 12)
                     kind = 12;
                  break;
               case 2:
                  if (kind > 15)
                     kind = 15;
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 0:
                  if ((jjbitVec0[i2] & l2) != 0L && kind > 15)
                     kind = 15;
                  break;
               case 1:
                  if ((jjbitVec0[i2] & l2) != 0L && kind > 12)
                     kind = 12;
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
         return curPos;
      try { curChar = input_stream.readChar(); }
      catch(java.io.IOException e) { return curPos; }
   }
private final intjjMoveNfa_3(int startState, int curPos)

   int[] nextStates;
   int startsAt = 0;
   jjnewStateCnt = 3;
   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 0:
               case 2:
                  if ((0xfffffffbffffffffL & l) == 0L)
                     break;
                  if (kind > 18)
                     kind = 18;
                  jjCheckNAdd(2);
                  break;
               case 1:
                  if (kind > 17)
                     kind = 17;
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else if (curChar < 128)
      {
         long l = 1L << (curChar & 077);
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 0:
                  if ((0xffffffffefffffffL & l) != 0L)
                  {
                     if (kind > 18)
                        kind = 18;
                     jjCheckNAdd(2);
                  }
                  else if (curChar == 92)
                     jjstateSet[jjnewStateCnt++] = 1;
                  break;
               case 1:
                  if (kind > 17)
                     kind = 17;
                  break;
               case 2:
                  if ((0xffffffffefffffffL & l) == 0L)
                     break;
                  if (kind > 18)
                     kind = 18;
                  jjCheckNAdd(2);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 0:
               case 2:
                  if ((jjbitVec0[i2] & l2) == 0L)
                     break;
                  if (kind > 18)
                     kind = 18;
                  jjCheckNAdd(2);
                  break;
               case 1:
                  if ((jjbitVec0[i2] & l2) != 0L && kind > 17)
                     kind = 17;
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
         return curPos;
      try { curChar = input_stream.readChar(); }
      catch(java.io.IOException e) { return curPos; }
   }
private final intjjMoveStringLiteralDfa0_0()

   switch(curChar)
   {
      case 10:
         return jjStartNfaWithStates_0(0, 2, 2);
      case 13:
         return jjStartNfaWithStates_0(0, 1, 2);
      case 34:
         return jjStopAtPos(0, 16);
      case 40:
         return jjStopAtPos(0, 7);
      case 47:
         return jjStopAtPos(0, 3);
      case 59:
         return jjStopAtPos(0, 4);
      case 61:
         return jjStopAtPos(0, 5);
      default :
         return jjMoveNfa_0(3, 0);
   }
private final intjjMoveStringLiteralDfa0_1()

   switch(curChar)
   {
      case 40:
         return jjStopAtPos(0, 10);
      case 41:
         return jjStopAtPos(0, 8);
      default :
         return jjMoveNfa_1(0, 0);
   }
private final intjjMoveStringLiteralDfa0_2()

   switch(curChar)
   {
      case 40:
         return jjStopAtPos(0, 13);
      case 41:
         return jjStopAtPos(0, 14);
      default :
         return jjMoveNfa_2(0, 0);
   }
private final intjjMoveStringLiteralDfa0_3()

   switch(curChar)
   {
      case 34:
         return jjStopAtPos(0, 19);
      default :
         return jjMoveNfa_3(0, 0);
   }
private final intjjStartNfaWithStates_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 intjjStartNfaWithStates_1(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_1(state, pos + 1);
private final intjjStartNfaWithStates_2(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_2(state, pos + 1);
private final intjjStartNfaWithStates_3(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_3(state, pos + 1);
private final intjjStartNfa_0(int pos, long active0)

   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
private final intjjStartNfa_1(int pos, long active0)

   return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
private final intjjStartNfa_2(int pos, long active0)

   return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
private final intjjStartNfa_3(int pos, long active0)

   return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
private final intjjStopAtPos(int pos, int kind)

   jjmatchedKind = kind;
   jjmatchedPos = pos;
   return pos + 1;
private final intjjStopStringLiteralDfa_0(int pos, long active0)

   switch (pos)
   {
      default :
         return -1;
   }
private final intjjStopStringLiteralDfa_1(int pos, long active0)

   switch (pos)
   {
      default :
         return -1;
   }
private final intjjStopStringLiteralDfa_2(int pos, long active0)

   switch (pos)
   {
      default :
         return -1;
   }
private final intjjStopStringLiteralDfa_3(int pos, long active0)

   switch (pos)
   {
      default :
         return -1;
   }
public voidsetDebugStream(java.io.PrintStream ds)

        debugStream = ds;