Yylex.java

  1. package org.drip.json.parser;

  3. /*
  4.  * -*- mode: java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  5.  */

  7. /*!
  8.  * Copyright (C) 2020 Lakshmi Krishnamurthy
  9.  * Copyright (C) 2019 Lakshmi Krishnamurthy
  10.  * Copyright (C) 2018 Lakshmi Krishnamurthy
  11.  * Copyright (C) 2017 Lakshmi Krishnamurthy
  12.  * Copyright (C) 2016 Lakshmi Krishnamurthy
  13.  * 
  14.  *  This file is part of DROP, an open-source library targeting analytics/risk, transaction cost analytics,
  15.  *      asset liability management analytics, capital, exposure, and margin analytics, valuation adjustment
  16.  *      analytics, and portfolio construction analytics within and across fixed income, credit, commodity,
  17.  *      equity, FX, and structured products. It also includes auxiliary libraries for algorithm support,
  18.  *      numerical analysis, numerical optimization, spline builder, model validation, statistical learning,
  19.  *      and computational support.
  20.  *  
  21.  *      https://lakshmidrip.github.io/DROP/
  22.  *  
  23.  *  DROP is composed of three modules:
  24.  *  
  25.  *  - DROP Product Core - https://lakshmidrip.github.io/DROP-Product-Core/
  26.  *  - DROP Portfolio Core - https://lakshmidrip.github.io/DROP-Portfolio-Core/
  27.  *  - DROP Computational Core - https://lakshmidrip.github.io/DROP-Computational-Core/
  28.  * 
  29.  *  DROP Product Core implements libraries for the following:
  30.  *  - Fixed Income Analytics
  31.  *  - Loan Analytics
  32.  *  - Transaction Cost Analytics
  33.  * 
  34.  *  DROP Portfolio Core implements libraries for the following:
  35.  *  - Asset Allocation Analytics
  36.  *  - Asset Liability Management Analytics
  37.  *  - Capital Estimation Analytics
  38.  *  - Exposure Analytics
  39.  *  - Margin Analytics
  40.  *  - XVA Analytics
  41.  * 
  42.  *  DROP Computational Core implements libraries for the following:
  43.  *  - Algorithm Support
  44.  *  - Computation Support
  45.  *  - Function Analysis
  46.  *  - Model Validation
  47.  *  - Numerical Analysis
  48.  *  - Numerical Optimizer
  49.  *  - Spline Builder
  50.  *  - Statistical Learning
  51.  * 
  52.  *  Documentation for DROP is Spread Over:
  53.  * 
  54.  *  - Main                     => https://lakshmidrip.github.io/DROP/
  55.  *  - Wiki                     => https://github.com/lakshmiDRIP/DROP/wiki
  56.  *  - GitHub                   => https://github.com/lakshmiDRIP/DROP
  57.  *  - Repo Layout Taxonomy     => https://github.com/lakshmiDRIP/DROP/blob/master/Taxonomy.md
  58.  *  - Javadoc                  => https://lakshmidrip.github.io/DROP/Javadoc/index.html
  59.  *  - Technical Specifications => https://github.com/lakshmiDRIP/DROP/tree/master/Docs/Internal
  60.  *  - Release Versions         => https://lakshmidrip.github.io/DROP/version.html
  61.  *  - Community Credits        => https://lakshmidrip.github.io/DROP/credits.html
  62.  *  - Issues Catalog           => https://github.com/lakshmiDRIP/DROP/issues
  63.  *  - JUnit                    => https://lakshmidrip.github.io/DROP/junit/index.html
  64.  *  - Jacoco                   => https://lakshmidrip.github.io/DROP/jacoco/index.html
  65.  * 
  66.  *  Licensed under the Apache License, Version 2.0 (the "License");
  67.  *      you may not use this file except in compliance with the License.
  68.  *   
  69.  *  You may obtain a copy of the License at
  70.  *      http://www.apache.org/licenses/LICENSE-2.0
  71.  *  
  72.  *  Unless required by applicable law or agreed to in writing, software
  73.  *      distributed under the License is distributed on an "AS IS" BASIS,
  74.  *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  75.  *  
  76.  *  See the License for the specific language governing permissions and
  77.  *      limitations under the License.
  78.  */

  80. /**
  81.  * <i>Yylex</i> is an Adaptation of the Yylex Class from the RFC4627 compliant JSON Simple
  82.  * (https://code.google.com/p/json-simple/).
  83.  *
  84.  *  <br><br>
  85.  *  <ul>
  86.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/NumericalCore.md">Numerical Core Module</a></li>
  87.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/AlgorithmSupportLibrary.md">Algorithm Support</a></li>
  88.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/json">JSON</a></li>
  89.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/json/parser">Parser</a></li>
  90.  *  </ul>
  91.  *
  92.  * @author Fang Yidong
  93.  * @author Lakshmi Krishnamurthy
  94.  */

  96. public class Yylex {

  98.       /** This character denotes the end of file */
  99.       public static final int YYEOF = -1;

  101.       /** initial size of the lookahead buffer */
  102.       private static final int ZZ_BUFFERSIZE = 16384;

  104.       /** lexical states */
  105.       public static final int YYINITIAL = 0;
  106.       public static final int STRING_BEGIN = 2;

  108.       /**
  109.        * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l
  110.        * ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l
  111.        *                  at the beginning of a line
  112.        * l is of the form l = 2*k, k a non negative integer
  113.        */
  114.       private static final int ZZ_LEXSTATE[] = { 
  115.          0,  0,  1, 1
  116.       };

  118.       /** 
  119.        * Translates characters to character classes
  120.        */
  121.       private static final String ZZ_CMAP_PACKED = 
  122.         "\11\0\1\7\1\7\2\0\1\7\22\0\1\7\1\0\1\11\10\0"+
  123.         "\1\6\1\31\1\2\1\4\1\12\12\3\1\32\6\0\4\1\1\5"+
  124.         "\1\1\24\0\1\27\1\10\1\30\3\0\1\22\1\13\2\1\1\21"+
  125.         "\1\14\5\0\1\23\1\0\1\15\3\0\1\16\1\24\1\17\1\20"+
  126.         "\5\0\1\25\1\0\1\26\uff82\0";

  128.       /** 
  129.        * Translates characters to character classes
  130.        */
  131.       private static final char [] ZZ_CMAP = zzUnpackCMap(ZZ_CMAP_PACKED);

  133.       /** 
  134.        * Translates DFA states to action switch labels.
  135.        */
  136.       private static final int [] ZZ_ACTION = zzUnpackAction();

  138.       private static final String ZZ_ACTION_PACKED_0 =
  139.         "\2\0\2\1\1\2\1\3\1\4\3\1\1\5\1\6"+
  140.         "\1\7\1\10\1\11\1\12\1\13\1\14\1\15\5\0"+
  141.         "\1\14\1\16\1\17\1\20\1\21\1\22\1\23\1\24"+
  142.         "\1\0\1\25\1\0\1\25\4\0\1\26\1\27\2\0"+
  143.         "\1\30";

  145.       private static int [] zzUnpackAction() {
  146.         int [] result = new int[45];
  147.         int offset = 0;
  148.         offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result);
  149.         return result;
  150.       }

  152.       private static int zzUnpackAction(String packed, int offset, int [] result) {
  153.         int i = 0;       /* index in packed string  */
  154.         int j = offset;  /* index in unpacked array */
  155.         int l = packed.length();
  156.         while (i < l) {
  157.           int count = packed.charAt(i++);
  158.           int value = packed.charAt(i++);
  159.           do result[j++] = value; while (--count > 0);
  160.         }
  161.         return j;
  162.       }


  165.       /** 
  166.        * Translates a state to a row index in the transition table
  167.        */
  168.       private static final int [] ZZ_ROWMAP = zzUnpackRowMap();

  170.       private static final String ZZ_ROWMAP_PACKED_0 =
  171.         "\0\0\0\33\0\66\0\121\0\154\0\207\0\66\0\242"+
  172.         "\0\275\0\330\0\66\0\66\0\66\0\66\0\66\0\66"+
  173.         "\0\363\0\u010e\0\66\0\u0129\0\u0144\0\u015f\0\u017a\0\u0195"+
  174.         "\0\66\0\66\0\66\0\66\0\66\0\66\0\66\0\66"+
  175.         "\0\u01b0\0\u01cb\0\u01e6\0\u01e6\0\u0201\0\u021c\0\u0237\0\u0252"+
  176.         "\0\66\0\66\0\u026d\0\u0288\0\66";

  178.       private static int [] zzUnpackRowMap() {
  179.         int [] result = new int[45];
  180.         int offset = 0;
  181.         offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result);
  182.         return result;
  183.       }

  185.       private static int zzUnpackRowMap(String packed, int offset, int [] result) {
  186.         int i = 0;  /* index in packed string  */
  187.         int j = offset;  /* index in unpacked array */
  188.         int l = packed.length();
  189.         while (i < l) {
  190.           int high = packed.charAt(i++) << 16;
  191.           result[j++] = high | packed.charAt(i++);
  192.         }
  193.         return j;
  194.       }

  196.       /** 
  197.        * The transition table of the DFA
  198.        */
  199.       private static final int ZZ_TRANS [] = {
  200.         2, 2, 3, 4, 2, 2, 2, 5, 2, 6, 
  201.         2, 2, 7, 8, 2, 9, 2, 2, 2, 2, 
  202.         2, 10, 11, 12, 13, 14, 15, 16, 16, 16, 
  203.         16, 16, 16, 16, 16, 17, 18, 16, 16, 16, 
  204.         16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
  205.         16, 16, 16, 16, -1, -1, -1, -1, -1, -1, 
  206.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  207.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  208.         -1, -1, -1, -1, 4, -1, -1, -1, -1, -1, 
  209.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  210.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  211.         -1, 4, 19, 20, -1, -1, -1, -1, -1, -1, 
  212.         -1, -1, -1, -1, -1, 20, -1, -1, -1, -1, 
  213.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  214.         -1, -1, 5, -1, -1, -1, -1, -1, -1, -1, 
  215.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  216.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  217.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  218.         21, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  219.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  220.         -1, -1, -1, -1, -1, 22, -1, -1, -1, -1, 
  221.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  222.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  223.         23, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  224.         -1, -1, -1, 16, 16, 16, 16, 16, 16, 16, 
  225.         16, -1, -1, 16, 16, 16, 16, 16, 16, 16, 
  226.         16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
  227.         -1, -1, -1, -1, -1, -1, -1, -1, 24, 25, 
  228.         26, 27, 28, 29, 30, 31, 32, -1, -1, -1, 
  229.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  230.         33, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  231.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  232.         -1, -1, -1, -1, -1, -1, 34, 35, -1, -1, 
  233.         34, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  234.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  235.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  236.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  237.         36, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  238.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  239.         -1, -1, -1, -1, -1, -1, -1, 37, -1, -1, 
  240.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  241.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  242.         -1, 38, -1, -1, -1, -1, -1, -1, -1, -1, 
  243.         -1, -1, -1, 39, -1, 39, -1, 39, -1, -1, 
  244.         -1, -1, -1, 39, 39, -1, -1, -1, -1, 39, 
  245.         39, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  246.         -1, -1, 33, -1, 20, -1, -1, -1, -1, -1, 
  247.         -1, -1, -1, -1, -1, -1, 20, -1, -1, -1, 
  248.         -1, -1, -1, -1, -1, -1, -1, -1, -1, 35, 
  249.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  250.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  251.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  252.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  253.         -1, -1, -1, 38, -1, -1, -1, -1, -1, -1, 
  254.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  255.         -1, -1, -1, -1, -1, -1, -1, -1, -1, 40, 
  256.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  257.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  258.         -1, -1, -1, -1, 41, -1, -1, -1, -1, -1, 
  259.         -1, -1, -1, -1, -1, 42, -1, 42, -1, 42, 
  260.         -1, -1, -1, -1, -1, 42, 42, -1, -1, -1, 
  261.         -1, 42, 42, -1, -1, -1, -1, -1, -1, -1, 
  262.         -1, -1, 43, -1, 43, -1, 43, -1, -1, -1, 
  263.         -1, -1, 43, 43, -1, -1, -1, -1, 43, 43, 
  264.         -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, 
  265.         -1, 44, -1, 44, -1, -1, -1, -1, -1, 44, 
  266.         44, -1, -1, -1, -1, 44, 44, -1, -1, -1, 
  267.         -1, -1, -1, -1, -1, 
  268.       };

  270.       /* error codes */
  271.       private static final int ZZ_UNKNOWN_ERROR = 0;
  272.       private static final int ZZ_NO_MATCH = 1;
  273.       private static final int ZZ_PUSHBACK_2BIG = 2;

  275.       /* error messages for the codes above */
  276.       private static final String ZZ_ERROR_MSG[] = {
  277.         "Unkown internal scanner error",
  278.         "Error: could not match input",
  279.         "Error: pushback value was too large"
  280.       };

  282.       /**
  283.        * ZZ_ATTRIBUTE[aState] contains the attributes of state <code>aState</code>
  284.        */
  285.       private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute();

  287.       private static final String ZZ_ATTRIBUTE_PACKED_0 =
  288.         "\2\0\1\11\3\1\1\11\3\1\6\11\2\1\1\11"+
  289.         "\5\0\10\11\1\0\1\1\1\0\1\1\4\0\2\11"+
  290.         "\2\0\1\11";

  292.       private static int [] zzUnpackAttribute() {
  293.         int [] result = new int[45];
  294.         int offset = 0;
  295.         offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result);
  296.         return result;
  297.       }

  299.       private static int zzUnpackAttribute(String packed, int offset, int [] result) {
  300.         int i = 0;       /* index in packed string  */
  301.         int j = offset;  /* index in unpacked array */
  302.         int l = packed.length();
  303.         while (i < l) {
  304.           int count = packed.charAt(i++);
  305.           int value = packed.charAt(i++);
  306.           do result[j++] = value; while (--count > 0);
  307.         }
  308.         return j;
  309.       }

  311.       /** the input device */
  312.       private java.io.Reader zzReader;

  314.       /** the current state of the DFA */
  315.       private int zzState;

  317.       /** the current lexical state */
  318.       private int zzLexicalState = YYINITIAL;

  320.       /** this buffer contains the current text to be matched and is
  321.           the source of the yytext() string */
  322.       private char zzBuffer[] = new char[ZZ_BUFFERSIZE];

  324.       /** the textposition at the last accepting state */
  325.       private int zzMarkedPos;

  327.       /** the current text position in the buffer */
  328.       private int zzCurrentPos;

  330.       /** startRead marks the beginning of the yytext() string in the buffer */
  331.       private int zzStartRead;

  333.       /** endRead marks the last character in the buffer, that has been read
  334.           from input */
  335.       private int zzEndRead;

  337.       /** number of newlines encountered up to the start of the matched text */
  338.       int yyline;

  340.       /** the number of characters up to the start of the matched text */
  341.       private int yychar;

  343.       /**
  344.        * the number of characters from the last newline up to the start of the 
  345.        * matched text
  346.        */
  347.       int yycolumn;

  349.       /** 
  350.        * zzAtBOL == true <=> the scanner is currently at the beginning of a line
  351.        */
  352.       boolean zzAtBOL = true;

  354.       /** zzAtEOF == true <=> the scanner is at the EOF */
  355.       private boolean zzAtEOF;

  357.       /* user code: */
  358.     private StringBuffer sb=new StringBuffer();

  360.     int getPosition(){
  361.             return yychar;
  362.     }



  366.       /**
  367.        * Creates a new scanner
  368.        * There is also a java.io.InputStream version of this constructor.
  369.        *
  370.        * @param   in  the java.io.Reader to read input from.
  371.        */
  372.       public Yylex(java.io.Reader in) {
  373.         this.zzReader = in;
  374.       }

  376.       /**
  377.        * Creates a new scanner.
  378.        * There is also java.io.Reader version of this constructor.
  379.        *
  380.        * @param   in  the java.io.Inputstream to read input from.
  381.        */
  382.       Yylex(java.io.InputStream in) {
  383.         this(new java.io.InputStreamReader(in));
  384.       }

  386.       /** 
  387.        * Unpacks the compressed character translation table.
  388.        *
  389.        * @param packed   the packed character translation table
  390.        * @return         the unpacked character translation table
  391.        */
  392.       private static char [] zzUnpackCMap(String packed) {
  393.         char [] map = new char[0x10000];
  394.         int i = 0;  /* index in packed string  */
  395.         int j = 0;  /* index in unpacked array */
  396.         while (i < 90) {
  397.           int  count = packed.charAt(i++);
  398.           char value = packed.charAt(i++);
  399.           do map[j++] = value; while (--count > 0);
  400.         }
  401.         return map;
  402.       }


  405.       /**
  406.        * Refills the input buffer.
  407.        *
  408.        * @return      <code>false</code>, iff there was new input.
  409.        * 
  410.        * @exception   java.io.IOException  if any I/O-Error occurs
  411.        */
  412.       private boolean zzRefill() throws java.io.IOException {

  414.         /* first: make room (if you can) */
  415.         if (zzStartRead > 0) {
  416.           System.arraycopy(zzBuffer, zzStartRead,
  417.                            zzBuffer, 0,
  418.                            zzEndRead-zzStartRead);

  420.           /* translate stored positions */
  421.           zzEndRead-= zzStartRead;
  422.           zzCurrentPos-= zzStartRead;
  423.           zzMarkedPos-= zzStartRead;
  424.           zzStartRead = 0;
  425.         }

  427.         /* is the buffer big enough? */
  428.         if (zzCurrentPos >= zzBuffer.length) {
  429.           /* if not: blow it up */
  430.           char newBuffer[] = new char[zzCurrentPos*2];
  431.           System.arraycopy(zzBuffer, 0, newBuffer, 0, zzBuffer.length);
  432.           zzBuffer = newBuffer;
  433.         }

  435.         /* finally: fill the buffer with new input */
  436.         int numRead = zzReader.read(zzBuffer, zzEndRead,
  437.                                                 zzBuffer.length-zzEndRead);

  439.         if (numRead > 0) {
  440.           zzEndRead+= numRead;
  441.           return false;
  442.         }
  443.         // unlikely but not impossible: read 0 characters, but not at end of stream    
  444.         if (numRead == 0) {
  445.           int c = zzReader.read();
  446.           if (c == -1) {
  447.             return true;
  448.           } else {
  449.             zzBuffer[zzEndRead++] = (char) c;
  450.             return false;
  451.           }     
  452.         }

  454.             // numRead < 0
  455.         return true;
  456.       }

  458.         
  459.       /**
  460.        * Closes the input stream.
  461.        * 
  462.        * @throws java.io.IOException Thrown if the Inputs are Invalid
  463.        */
  464.       public final void yyclose() throws java.io.IOException {
  465.         zzAtEOF = true;            /* indicate end of file */
  466.         zzEndRead = zzStartRead;  /* invalidate buffer    */

  468.         if (zzReader != null)
  469.           zzReader.close();
  470.       }


  473.       /**
  474.        * Resets the scanner to read from a new input stream.
  475.        * Does not close the old reader.
  476.        *
  477.        * All internal variables are reset, the old input stream 
  478.        * <b>cannot</b> be reused (internal buffer is discarded and lost).
  479.        *
  480.        * @param reader   the new input stream 
  481.        */
  482.       public final void yyreset(java.io.Reader reader) {
  483.         zzReader = reader;
  484.         zzAtBOL  = true;
  485.         zzAtEOF  = false;
  486.         zzEndRead = zzStartRead = 0;
  487.         zzCurrentPos = zzMarkedPos = 0;
  488.         yyline = yychar = yycolumn = 0;
  489.         zzLexicalState = YYINITIAL;
  490.       }


  493.       /**
  494.        * Returns the current lexical state.
  495.        * 
  496.        * @return The Current Lexical State.
  497.        */

  499.       public final int yystate() {
  500.         return zzLexicalState;
  501.       }


  504.       /**
  505.        * Enters a new lexical state
  506.        *
  507.        * @param newState the new lexical state
  508.        */
  509.       public final void yybegin(int newState) {
  510.         zzLexicalState = newState;
  511.       }


  514.       /**
  515.        * Returns the text matched by the current regular expression.
  516.        * 
  517.        * @return The Text.
  518.        */

  520.       public final String yytext() {
  521.         return new String( zzBuffer, zzStartRead, zzMarkedPos-zzStartRead );
  522.       }


  525.       /**
  526.        * Returns the character at position <b>pos</b> from the 
  527.        * matched text. 
  528.        * 
  529.        * It is equivalent to yytext().charAt(pos), but faster
  530.        *
  531.        * @param pos the position of the character to fetch. 
  532.        *            A value from 0 to yylength()-1.
  533.        *
  534.        * @return the character at position pos
  535.        */
  536.       public final char yycharat(int pos) {
  537.         return zzBuffer[zzStartRead+pos];
  538.       }


  541.       /**
  542.        * Returns the length of the matched text region.
  543.        * 
  544.        * @return The Length.
  545.        */
  546.       public final int yylength() {
  547.         return zzMarkedPos-zzStartRead;
  548.       }


  551.       /**
  552.        * Reports an error that occured while scanning.
  553.        *
  554.        * In a wellformed scanner (no or only correct usage of 
  555.        * yypushback(int) and a match-all fallback rule) this method 
  556.        * will only be called with things that "Can't Possibly Happen".
  557.        * If this method is called, something is seriously wrong
  558.        * (e.g. a JFlex bug producing a faulty scanner etc.).
  559.        *
  560.        * Usual syntax/scanner level error handling should be done
  561.        * in error fallback rules.
  562.        *
  563.        * @param   errorCode  the code of the errormessage to display
  564.        */
  565.       private void zzScanError(int errorCode) {
  566.         String message;
  567.         try {
  568.           message = ZZ_ERROR_MSG[errorCode];
  569.         }
  570.         catch (ArrayIndexOutOfBoundsException e) {
  571.           message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR];
  572.         }

  574.         throw new Error(message);
  575.       } 


  578.       /**
  579.        * Pushes the specified amount of characters back into the input stream.
  580.        *
  581.        * They will be read again by then next call of the scanning method
  582.        *
  583.        * @param number  the number of characters to be read again.
  584.        *                This number must not be greater than yylength()!
  585.        */
  586.       public void yypushback(int number)  {
  587.         if ( number > yylength() )
  588.           zzScanError(ZZ_PUSHBACK_2BIG);

  590.         zzMarkedPos -= number;
  591.       }


  594.       /**
  595.        * Resumes scanning until the next regular expression is matched,
  596.        * the end of input is encountered or an I/O-Error occurs.
  597.        *
  598.        * @return      the next token
  599.        * 
  600.        * @throws   java.io.IOException  if any I/O-Error occurs
  601.        * 
  602.        * @throws ParseException Thrown if Inputs are Invalid
  603.        */

  605.       public Yytoken yylex() throws java.io.IOException, ParseException {
  606.         int zzInput;
  607.         int zzAction;

  609.         // cached fields:
  610.         int zzCurrentPosL;
  611.         int zzMarkedPosL;
  612.         int zzEndReadL = zzEndRead;
  613.         char [] zzBufferL = zzBuffer;
  614.         char [] zzCMapL = ZZ_CMAP;

  616.         int [] zzTransL = ZZ_TRANS;
  617.         int [] zzRowMapL = ZZ_ROWMAP;
  618.         int [] zzAttrL = ZZ_ATTRIBUTE;

  620.         while (true) {
  621.           zzMarkedPosL = zzMarkedPos;

  623.           yychar+= zzMarkedPosL-zzStartRead;

  625.           zzAction = -1;

  627.           zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL;
  628.       
  629.           zzState = ZZ_LEXSTATE[zzLexicalState];


  632.           zzForAction: {
  633.             while (true) {
  634.         
  635.               if (zzCurrentPosL < zzEndReadL)
  636.                 zzInput = zzBufferL[zzCurrentPosL++];
  637.               else if (zzAtEOF) {
  638.                 zzInput = YYEOF;
  639.                 break zzForAction;
  640.               }
  641.               else {
  642.                 // store back cached positions
  643.                 zzCurrentPos  = zzCurrentPosL;
  644.                 zzMarkedPos   = zzMarkedPosL;
  645.                 boolean eof = zzRefill();
  646.                 // get translated positions and possibly new buffer
  647.                 zzCurrentPosL  = zzCurrentPos;
  648.                 zzMarkedPosL   = zzMarkedPos;
  649.                 zzBufferL      = zzBuffer;
  650.                 zzEndReadL     = zzEndRead;
  651.                 if (eof) {
  652.                   zzInput = YYEOF;
  653.                   break zzForAction;
  654.                 }
  655.                 else {
  656.                   zzInput = zzBufferL[zzCurrentPosL++];
  657.                 }
  658.               }
  659.               int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ];
  660.               if (zzNext == -1) break zzForAction;
  661.               zzState = zzNext;

  663.               int zzAttributes = zzAttrL[zzState];
  664.               if ( (zzAttributes & 1) == 1 ) {
  665.                 zzAction = zzState;
  666.                 zzMarkedPosL = zzCurrentPosL;
  667.                 if ( (zzAttributes & 8) == 8 ) break zzForAction;
  668.               }

  670.             }
  671.           }

  673.           // store back cached position
  674.           zzMarkedPos = zzMarkedPosL;

  676.           switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) {
  677.             case 11: 
  678.               { sb.append(yytext());
  679.               }
  680.             case 25: break;
  681.             case 4: 
  682.               { sb.delete(0, sb.length());yybegin(STRING_BEGIN);
  683.               }
  684.             case 26: break;
  685.             case 16: 
  686.               { sb.append('\b');
  687.               }
  688.             case 27: break;
  689.             case 6: 
  690.               { return new Yytoken(Yytoken.TYPE_RIGHT_BRACE,null);
  691.               }
  692.             case 28: break;
  693.             case 23: 
  694.               { Boolean val=Boolean.valueOf(yytext()); return new Yytoken(Yytoken.TYPE_VALUE, val);
  695.               }
  696.             case 29: break;
  697.             case 22: 
  698.               { return new Yytoken(Yytoken.TYPE_VALUE, null);
  699.               }
  700.             case 30: break;
  701.             case 13: 
  702.               { yybegin(YYINITIAL);return new Yytoken(Yytoken.TYPE_VALUE, sb.toString());
  703.               }
  704.             case 31: break;
  705.             case 12: 
  706.               { sb.append('\\');
  707.               }
  708.             case 32: break;
  709.             case 21: 
  710.               { Double val=Double.valueOf(yytext()); return new Yytoken(Yytoken.TYPE_VALUE, val);
  711.               }
  712.             case 33: break;
  713.             case 1: 
  714.               { throw new ParseException(yychar, ParseException.ERROR_UNEXPECTED_CHAR, yycharat (0));
  715.               }
  716.             case 34: break;
  717.             case 8: 
  718.               { return new Yytoken(Yytoken.TYPE_RIGHT_SQUARE,null);
  719.               }
  720.             case 35: break;
  721.             case 19: 
  722.               { sb.append('\r');
  723.               }
  724.             case 36: break;
  725.             case 15: 
  726.               { sb.append('/');
  727.               }
  728.             case 37: break;
  729.             case 10: 
  730.               { return new Yytoken(Yytoken.TYPE_COLON,null);
  731.               }
  732.             case 38: break;
  733.             case 14: 
  734.               { sb.append('"');
  735.               }
  736.             case 39: break;
  737.             case 5: 
  738.               { return new Yytoken(Yytoken.TYPE_LEFT_BRACE,null);
  739.               }
  740.             case 40: break;
  741.             case 17: 
  742.               { sb.append('\f');
  743.               }
  744.             case 41: break;
  745.             case 24: 
  746.               { try{
  747.                                                                                                                     int ch=Integer.parseInt(yytext().substring(2),16);
  748.                                                                                                                     sb.append((char)ch);
  749.                                                                                                             }
  750.                                                                                                             catch(Exception e){
  751.                                                                                                                     throw new ParseException(yychar, ParseException.ERROR_UNEXPECTED_EXCEPTION, e);
  752.                                                                                                             }
  753.               }
  754.             case 42: break;
  755.             case 20: 
  756.               { sb.append('\t');
  757.               }
  758.             case 43: break;
  759.             case 7: 
  760.               { return new Yytoken(Yytoken.TYPE_LEFT_SQUARE,null);
  761.               }
  762.             case 44: break;
  763.             case 2: 
  764.               { Long val=Long.valueOf(yytext()); return new Yytoken(Yytoken.TYPE_VALUE, val);
  765.               }
  766.             case 45: break;
  767.             case 18: 
  768.               { sb.append('\n');
  769.               }
  770.             case 46: break;
  771.             case 9: 
  772.               { return new Yytoken(Yytoken.TYPE_COMMA,null);
  773.               }
  774.             case 47: break;
  775.             case 3: 
  776.               { 
  777.               }
  778.             case 48: break;
  779.             default: 
  780.               if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
  781.                 zzAtEOF = true;
  782.                 return null;
  783.               } 
  784.               else {
  785.                 zzScanError(ZZ_NO_MATCH);
  786.               }
  787.           }
  788.         }
  789.       }
  790.     }
Created with JaCoCo 0.7.9.201702052155