javaparsertokenmanager.java

java覆盖率测试工具

				return jjMoveStringLiteralDfa3_0(active0, 0x1000000004000000L, active1, 0L);
			case 119:
				if ((active0 & 0x80000000000L) != 0L)
					return jjStartNfaWithStates_0(2, 43, 28);
				break;
			case 121:
				if ((active0 & 0x2000000000000000L) != 0L)
					return jjStartNfaWithStates_0(2, 61, 28);
				break;
			default:
				break;
		}
		return jjStartNfa_0(1, active0, active1);
	}

	private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
	{
		if (((active0 &= old0) | (active1 &= old1)) == 0L)
			return jjStartNfa_0(1, old0, old1);
		try
		{
			curChar = input_stream.readChar();
		}
		catch (java.io.IOException e)
		{
			jjStopStringLiteralDfa_0(2, active0, active1);
			return 3;
		}
		switch (curChar)
		{
			case 61:
				if ((active1 & 0x200000000000000L) != 0L)
					return jjStopAtPos(3, 121);
				break;
			case 97:
				return jjMoveStringLiteralDfa4_0(active0, 0x80000001c1010000L, active1, 0L);
			case 98:
				return jjMoveStringLiteralDfa4_0(active0, 0x4000000L, active1, 0L);
			case 99:
				return jjMoveStringLiteralDfa4_0(active0, 0x80000000080000L, active1, 0L);
			case 100:
				if ((active0 & 0x4000000000000000L) != 0L)
					return jjStartNfaWithStates_0(3, 62, 28);
				break;
			case 101:
				if ((active0 & 0x20000L) != 0L)
					return jjStartNfaWithStates_0(3, 17, 28);
				else if ((active0 & 0x40000L) != 0L)
					return jjStartNfaWithStates_0(3, 18, 28);
				else if ((active0 & 0x8000000L) != 0L)
					return jjStartNfaWithStates_0(3, 27, 28);
				else if ((active0 & 0x1000000000000000L) != 0L)
					return jjStartNfaWithStates_0(3, 60, 28);
				return jjMoveStringLiteralDfa4_0(active0, 0x20010010004000L, active1, 0L);
			case 103:
				if ((active0 & 0x20000000000L) != 0L)
					return jjStartNfaWithStates_0(3, 41, 28);
				break;
			case 105:
				return jjMoveStringLiteralDfa4_0(active0, 0x10040000000000L, active1, 0L);
			case 107:
				return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0L);
			case 108:
				if ((active0 & 0x100000000000L) != 0L)
					return jjStartNfaWithStates_0(3, 44, 28);
				return jjMoveStringLiteralDfa4_0(active0, 0x1001000008000L, active1, 0x1L);
			case 110:
				return jjMoveStringLiteralDfa4_0(active0, 0x800000000000000L, active1, 0L);
			case 111:
				if ((active0 & 0x400000000L) != 0L)
					return jjStartNfaWithStates_0(3, 34, 28);
				return jjMoveStringLiteralDfa4_0(active0, 0x600002000000000L, active1, 0L);
			case 114:
				if ((active0 & 0x100000L) != 0L)
					return jjStartNfaWithStates_0(3, 20, 28);
				return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L, active1, 0L);
			case 115:
				if ((active0 & 0x100000000000000L) != 0L)
					return jjStartNfaWithStates_0(3, 56, 28);
				return jjMoveStringLiteralDfa4_0(active0, 0x20600000L, active1, 0L);
			case 116:
				return jjMoveStringLiteralDfa4_0(active0, 0x48804000802000L, active1, 0L);
			case 117:
				return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0L);
			case 118:
				return jjMoveStringLiteralDfa4_0(active0, 0x400000000000L, active1, 0L);
			default:
				break;
		}
		return jjStartNfa_0(2, active0, active1);
	}

	private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
	{
		if (((active0 &= old0) | (active1 &= old1)) == 0L)
			return jjStartNfa_0(2, old0, old1);
		try
		{
			curChar = input_stream.readChar();
		}
		catch (java.io.IOException e)
		{
			jjStopStringLiteralDfa_0(3, active0, active1);
			return 4;
		}
		switch (curChar)
		{
			case 97:
				return jjMoveStringLiteralDfa5_0(active0, 0x604000000000L, active1, 0L);
			case 99:
				return jjMoveStringLiteralDfa5_0(active0, 0x50000000000000L, active1, 0L);
			case 101:
				if ((active0 & 0x20000000L) != 0L)
					return jjStartNfaWithStates_0(4, 29, 28);
				else if ((active1 & 0x1L) != 0L)
					return jjStartNfaWithStates_0(4, 64, 28);
				return jjMoveStringLiteralDfa5_0(active0, 0x801000008000L, active1, 0L);
			case 104:
				if ((active0 & 0x80000L) != 0L)
					return jjStartNfaWithStates_0(4, 19, 28);
				return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L, active1, 0L);
			case 105:
				return jjMoveStringLiteralDfa5_0(active0, 0x9000000800000L, active1, 0L);
			case 107:
				if ((active0 & 0x10000L) != 0L)
					return jjStartNfaWithStates_0(4, 16, 28);
				break;
			case 108:
				if ((active0 & 0x40000000L) != 0L)
				{
					jjmatchedKind = 30;
					jjmatchedPos = 4;
				}
				return jjMoveStringLiteralDfa5_0(active0, 0x84000000L, active1, 0L);
			case 110:
				return jjMoveStringLiteralDfa5_0(active0, 0x10000000L, active1, 0L);
			case 114:
				if ((active0 & 0x20000000000000L) != 0L)
					return jjStartNfaWithStates_0(4, 53, 28);
				return jjMoveStringLiteralDfa5_0(active0, 0x2012000006000L, active1, 0L);
			case 115:
				if ((active0 & 0x200000L) != 0L)
					return jjStartNfaWithStates_0(4, 21, 28);
				return jjMoveStringLiteralDfa5_0(active0, 0x800000000000000L, active1, 0L);
			case 116:
				if ((active0 & 0x400000L) != 0L)
					return jjStartNfaWithStates_0(4, 22, 28);
				else if ((active0 & 0x100000000L) != 0L)
					return jjStartNfaWithStates_0(4, 32, 28);
				else if ((active0 & 0x4000000000000L) != 0L)
					return jjStartNfaWithStates_0(4, 50, 28);
				return jjMoveStringLiteralDfa5_0(active0, 0x8000000000000000L, active1, 0L);
			case 117:
				return jjMoveStringLiteralDfa5_0(active0, 0x1000000L, active1, 0L);
			case 118:
				return jjMoveStringLiteralDfa5_0(active0, 0x40000000000L, active1, 0L);
			case 119:
				if ((active0 & 0x200000000000000L) != 0L)
				{
					jjmatchedKind = 57;
					jjmatchedPos = 4;
				}
				return jjMoveStringLiteralDfa5_0(active0, 0x400000000000000L, active1, 0L);
			default:
				break;
		}
		return jjStartNfa_0(3, active0, active1);
	}

	private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1)
	{
		if (((active0 &= old0) | (active1 &= old1)) == 0L)
			return jjStartNfa_0(3, old0, old1);
		try
		{
			curChar = input_stream.readChar();
		}
		catch (java.io.IOException e)
		{
			jjStopStringLiteralDfa_0(4, active0, 0L);
			return 5;
		}
		switch (curChar)
		{
			case 97:
				return jjMoveStringLiteralDfa6_0(active0, 0xa000L);
			case 99:
				if ((active0 & 0x1000000000000L) != 0L)
					return jjStartNfaWithStates_0(5, 48, 28);
				else if ((active0 & 0x8000000000000L) != 0L)
					return jjStartNfaWithStates_0(5, 51, 28);
				return jjMoveStringLiteralDfa6_0(active0, 0x800000000000L);
			case 100:
				return jjMoveStringLiteralDfa6_0(active0, 0x10000000L);
			case 101:
				if ((active0 & 0x4000000L) != 0L)
					return jjStartNfaWithStates_0(5, 26, 28);
				else if ((active0 & 0x40000000000L) != 0L)
					return jjStartNfaWithStates_0(5, 42, 28);
				break;
			case 102:
				return jjMoveStringLiteralDfa6_0(active0, 0x10000000000L);
			case 103:
				return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L);
			case 104:
				if ((active0 & 0x40000000000000L) != 0L)
					return jjStartNfaWithStates_0(5, 54, 28);
				break;
			case 105:
				return jjMoveStringLiteralDfa6_0(active0, 0x8800000000000000L);
			case 108:
				return jjMoveStringLiteralDfa6_0(active0, 0x81000000L);
			case 109:
				return jjMoveStringLiteralDfa6_0(active0, 0x1000000000L);
			case 110:
				if ((active0 & 0x2000000000000L) != 0L)
					return jjStartNfaWithStates_0(5, 49, 28);
				return jjMoveStringLiteralDfa6_0(active0, 0x4000800000L);
			case 114:
				return jjMoveStringLiteralDfa6_0(active0, 0x80000000000000L);
			case 115:
				if ((active0 & 0x400000000000000L) != 0L)
					return jjStartNfaWithStates_0(5, 58, 28);
				break;
			case 116:
				if ((active0 & 0x4000L) != 0L)
					return jjStartNfaWithStates_0(5, 14, 28);
				else if ((active0 & 0x2000000000L) != 0L)
					return jjStartNfaWithStates_0(5, 37, 28);
				return jjMoveStringLiteralDfa6_0(active0, 0x10400000000000L);
			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 97:
				return jjMoveStringLiteralDfa7_0(active0, 0x10000000000L);
			case 99:
				return jjMoveStringLiteralDfa7_0(active0, 0x4000002000L);
			case 101:
				if ((active0 & 0x200000000000L) != 0L)
					return jjStartNfaWithStates_0(6, 45, 28);
				else if ((active0 & 0x400000000000L) != 0L)
					return jjStartNfaWithStates_0(6, 46, 28);
				return jjMoveStringLiteralDfa7_0(active0, 0x800001000000000L);
			case 102:
				return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L);
			case 108:
				return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000000L);
			case 110:
				if ((active0 & 0x8000L) != 0L)
					return jjStartNfaWithStates_0(6, 15, 28);
				break;
			case 111:
				return jjMoveStringLiteralDfa7_0(active0, 0x80000000000000L);
			case 115:
				if ((active0 & 0x10000000L) != 0L)
					return jjStartNfaWithStates_0(6, 28, 28);
				break;
			case 116:
				if ((active0 & 0x1000000L) != 0L)
					return jjStartNfaWithStates_0(6, 24, 28);
				return jjMoveStringLiteralDfa7_0(active0, 0x800000000000L);
			case 117:
				return jjMoveStringLiteralDfa7_0(active0, 0x800000L);
			case 121:
				if ((active0 & 0x80000000L) != 0L)
					return jjStartNfaWithStates_0(6, 31, 28);
				break;
			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, 0x10000000000L);
			case 101:
				if ((active0 & 0x800000L) != 0L)
					return jjStartNfaWithStates_0(7, 23, 28);
				else if ((active0 & 0x8000000000000000L) != 0L)
					return jjStartNfaWithStates_0(7, 63, 28);
				return jjMoveStringLiteralDfa8_0(active0, 0x804000000000L);
			case 110:
				return jjMoveStringLiteralDfa8_0(active0, 0x880001000000000L);
			case 112:
				if ((active0 & 0x10000000000000L) != 0L)
					return jjStartNfaWithStates_0(7, 52, 28);
				break;
			case 116:
				if ((active0 & 0x2000L) != 0L)
					return jjStartNfaWithStates_0(7, 13, 28);
				break;
			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 100:
				if ((active0 & 0x800000000000L) != 0L)
					return jjStartNfaWithStates_0(8, 47, 28);
				break;
			case 101:
				if ((active0 & 0x10000000000L) != 0L)
					return jjStartNfaWithStates_0(8, 40, 28);
				break;
			case 105:
				return jjMoveStringLiteralDfa9_0(active0, 0x80000000000000L);
			case 111:
				return jjMoveStringLiteralDfa9_0(active0, 0x4000000000L);
			case 116:
				if ((active0 & 0x800000000000000L) != 0L)
					return jjStartNfaWithStates_0(8, 59, 28);
				return jjMoveStringLiteralDfa9_0(active0, 0x1000000000L);
			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 102:
				if ((active0 & 0x4000000000L) != 0L)
					return jjStartNfaWithStates_0(9, 38, 28);
				break;
			case 115:
				if ((active0 & 0x1000000000L) != 0L)
					return jjStartNfaWithStates_0(9, 36, 28);
				break;
			case 122:
				return jjMoveStringLiteralDfa10_0(active0, 0x80000000000000L);
			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 101:
				return jjMoveStringLiteralDfa11_0(active0, 0x80000000000000L);
			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 100:
				if ((active0 & 0x80000000000000L) != 0L)
					return jjStartNfaWithStates_0(11, 55, 28);
				break;
			default:
				break;
		}
		return jjStartNfa_0(10, 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)
	{