JSONParser.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>JSONParser</i> is an Adaptation of the JSONParser 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/ComputationalCore.md">Computational Core Module</a></li>
  87.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationSupportLibrary.md">Computation Support</a></li>
  88.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/json">RFC-4627 Compliant JSON Encoder/Decoder (Parser)</a></li>
  89.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/json/parser">RFC4627 Compliant JSON Message Parser</a></li>
  90.  *  </ul>
  91.  *
  92.  * @author Fang Yidong
  93.  * @author Lakshmi Krishnamurthy
  94.  */

  96. public class JSONParser {
  97.     public static final int S_INIT=0;
  98.     public static final int S_IN_FINISHED_VALUE=1;//string,number,boolean,null,object,array
  99.     public static final int S_IN_OBJECT=2;
  100.     public static final int S_IN_ARRAY=3;
  101.     public static final int S_PASSED_PAIR_KEY=4;
  102.     public static final int S_IN_PAIR_VALUE=5;
  103.     public static final int S_END=6;
  104.     public static final int S_IN_ERROR=-1;
  105.     
  106.     @SuppressWarnings ("rawtypes") private java.util.LinkedList handlerStatusStack;

  108.     private Yylex lexer = new Yylex((java.io.Reader)null);
  109.     private Yytoken token = null;
  110.     private int status = S_INIT;
  111.     
  112.     @SuppressWarnings ("rawtypes") private int peekStatus(java.util.LinkedList statusStack){
  113.             if(statusStack.size()==0)
  114.                     return -1;
  115.             Integer status=(Integer)statusStack.getFirst();
  116.             return status.intValue();
  117.     }
  118.     
  119. /**
  120.  *  Reset the parser to the initial state without resetting the underlying reader.
  121.  *
  122.  */
  123. public void reset(){
  124.     token = null;
  125.     status = S_INIT;
  126.     handlerStatusStack = null;
  127. }

  129. /**
  130.  * Reset the parser to the initial state with a new character reader.
  131.  * 
  132.  * @param in - The new character reader.
  133.  */
  134.     public void reset(java.io.Reader in){
  135.             lexer.yyreset(in);
  136.             reset();
  137.     }
  138.     
  139.     /**
  140.      * @return The position of the beginning of the current token.
  141.      */
  142.     public int getPosition(){
  143.             return lexer.getPosition();
  144.     }
  145.     
  146.     public Object parse(String s) throws ParseException{
  147.             return parse(s, (ContainerFactory)null);
  148.     }
  149.     
  150.     /**
  151.      * Parse the JSON String
  152.      * 
  153.      * @param s The String
  154.      * @param containerFactory The Container Factory
  155.      * 
  156.      * @return The JSON Object
  157.      * 
  158.      * @throws ParseException Thrown if the Inputs are Invalid
  159.      */

  161.     public Object parse(String s, ContainerFactory containerFactory) throws ParseException{
  162.         java.io.StringReader in=new java.io.StringReader(s);
  163.             try{
  164.                     return parse(in, containerFactory);
  165.             }
  166.             catch(java.io.IOException ie){
  167.                     /*
  168.                      * Actually it will never happen.
  169.                      */
  170.                     throw new ParseException(-1, ParseException.ERROR_UNEXPECTED_EXCEPTION, ie);
  171.             }
  172.     }
  173.     
  174.     public Object parse(java.io.Reader in) throws java.io.IOException, ParseException{
  175.             return parse(in, (ContainerFactory)null);
  176.     }
  177.     
  178.     /**
  179.      * Parse JSON text into java object from the input source.
  180.      *      
  181.      * @param in The Input Reader
  182.  * @param containerFactory - Use this factory to createyour own JSON object and JSON array containers.
  183.      * @return Instance of the following:
  184.      *  org.json.simple.JSONObject,
  185.      *      org.json.simple.JSONArray,
  186.      *      java.lang.String,
  187.      *      java.lang.Number,
  188.      *      java.lang.Boolean,
  189.      *      null
  190.      * 
  191.      * @throws java.io.IOException Thrown if the Inputs are Invalid
  192.      * 
  193.      * @throws ParseException Thrown if the Inputs are Invalid
  194.      */
  195.     @SuppressWarnings ({"rawtypes", "unchecked"}) public Object parse(java.io.Reader in, ContainerFactory containerFactory) throws java.io.IOException, ParseException{
  196.             reset(in);
  197.             java.util.LinkedList statusStack = new java.util.LinkedList();
  198.             java.util.LinkedList valueStack = new java.util.LinkedList();
  199.             
  200.             try{
  201.                     do{
  202.                             nextToken();
  203.                             switch(status){
  204.                             case S_INIT:
  205.                                     switch(token.type){
  206.                                     case Yytoken.TYPE_VALUE:
  207.                                             status=S_IN_FINISHED_VALUE;
  208.                                             statusStack.addFirst(status);
  209.                                             valueStack.addFirst(token.value);
  210.                                             break;
  211.                                     case Yytoken.TYPE_LEFT_BRACE:
  212.                                             status=S_IN_OBJECT;
  213.                                             statusStack.addFirst(status);
  214.                                             valueStack.addFirst(createObjectContainer(containerFactory));
  215.                                             break;
  216.                                     case Yytoken.TYPE_LEFT_SQUARE:
  217.                                             status=S_IN_ARRAY;
  218.                                             statusStack.addFirst(status);
  219.                                             valueStack.addFirst(createArrayContainer(containerFactory));
  220.                                             break;
  221.                                     default:
  222.                                             status=S_IN_ERROR;
  223.                                     }//inner switch
  224.                                     break;
  225.                                     
  226.                             case S_IN_FINISHED_VALUE:
  227.                                     if(token.type==Yytoken.TYPE_EOF)
  228.                                             return valueStack.removeFirst();
  229.                                     else
  230.                                             throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
  231.                                     
  232.                             case S_IN_OBJECT:
  233.                                     switch(token.type){
  234.                                     case Yytoken.TYPE_COMMA:
  235.                                             break;
  236.                                     case Yytoken.TYPE_VALUE:
  237.                                             if(token.value instanceof String){
  238.                                                     String key=(String)token.value;
  239.                                                     valueStack.addFirst(key);
  240.                                                     status=S_PASSED_PAIR_KEY;
  241.                                                     statusStack.addFirst(status);
  242.                                             }
  243.                                             else{
  244.                                                     status=S_IN_ERROR;
  245.                                             }
  246.                                             break;
  247.                                     case Yytoken.TYPE_RIGHT_BRACE:
  248.                                             if(valueStack.size()>1){
  249.                                                     statusStack.removeFirst();
  250.                                                     valueStack.removeFirst();
  251.                                                     status=peekStatus(statusStack);
  252.                                             }
  253.                                             else{
  254.                                                     status=S_IN_FINISHED_VALUE;
  255.                                             }
  256.                                             break;
  257.                                     default:
  258.                                             status=S_IN_ERROR;
  259.                                             break;
  260.                                     }//inner switch
  261.                                     break;
  262.                                     
  263.                             case S_PASSED_PAIR_KEY:
  264.                                     switch(token.type){
  265.                                     case Yytoken.TYPE_COLON:
  266.                                             break;
  267.                                     case Yytoken.TYPE_VALUE:
  268.                                             statusStack.removeFirst();
  269.                                             String key=(String)valueStack.removeFirst();
  270.                                             java.util.Map parent=(java.util.Map)valueStack.getFirst();
  271.                                             parent.put(key,token.value);
  272.                                             status=peekStatus(statusStack);
  273.                                             break;
  274.                                     case Yytoken.TYPE_LEFT_SQUARE:
  275.                                             statusStack.removeFirst();
  276.                                             key=(String)valueStack.removeFirst();
  277.                                             parent=(java.util.Map)valueStack.getFirst();
  278.                                             java.util.List newArray=createArrayContainer(containerFactory);
  279.                                             parent.put(key,newArray);
  280.                                             status=S_IN_ARRAY;
  281.                                             statusStack.addFirst(status);
  282.                                             valueStack.addFirst(newArray);
  283.                                             break;
  284.                                     case Yytoken.TYPE_LEFT_BRACE:
  285.                                             statusStack.removeFirst();
  286.                                             key=(String)valueStack.removeFirst();
  287.                                             parent=(java.util.Map)valueStack.getFirst();
  288.                                             java.util.Map newObject=createObjectContainer(containerFactory);
  289.                                             parent.put(key,newObject);
  290.                                             status=S_IN_OBJECT;
  291.                                             statusStack.addFirst(status);
  292.                                             valueStack.addFirst(newObject);
  293.                                             break;
  294.                                     default:
  295.                                             status=S_IN_ERROR;
  296.                                     }
  297.                                     break;
  298.                                     
  299.                             case S_IN_ARRAY:
  300.                                     switch(token.type){
  301.                                     case Yytoken.TYPE_COMMA:
  302.                                             break;
  303.                                     case Yytoken.TYPE_VALUE:
  304.                                         java.util.List val=(java.util.List)valueStack.getFirst();
  305.                                             val.add(token.value);
  306.                                             break;
  307.                                     case Yytoken.TYPE_RIGHT_SQUARE:
  308.                                             if(valueStack.size()>1){
  309.                                                     statusStack.removeFirst();
  310.                                                     valueStack.removeFirst();
  311.                                                     status=peekStatus(statusStack);
  312.                                             }
  313.                                             else{
  314.                                                     status=S_IN_FINISHED_VALUE;
  315.                                             }
  316.                                             break;
  317.                                     case Yytoken.TYPE_LEFT_BRACE:
  318.                                             val=(java.util.List)valueStack.getFirst();
  319.                                             java.util.Map newObject=createObjectContainer(containerFactory);
  320.                                             val.add(newObject);
  321.                                             status=S_IN_OBJECT;
  322.                                             statusStack.addFirst(status);
  323.                                             valueStack.addFirst(newObject);
  324.                                             break;
  325.                                     case Yytoken.TYPE_LEFT_SQUARE:
  326.                                             val=(java.util.List)valueStack.getFirst();
  327.                                             java.util.List newArray=createArrayContainer(containerFactory);
  328.                                             val.add(newArray);
  329.                                             status=S_IN_ARRAY;
  330.                                             statusStack.addFirst(status);
  331.                                             valueStack.addFirst(newArray);
  332.                                             break;
  333.                                     default:
  334.                                             status=S_IN_ERROR;
  335.                                     }//inner switch
  336.                                     break;
  337.                             case S_IN_ERROR:
  338.                                     throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
  339.                             }//switch
  340.                             if(status==S_IN_ERROR){
  341.                                     throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
  342.                             }
  343.                     }while(token.type!=Yytoken.TYPE_EOF);
  344.             }
  345.             catch(java.io.IOException ie){
  346.                     throw ie;
  347.             }
  348.             
  349.             throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
  350.     }
  351.     
  352.     private void nextToken() throws ParseException, java.io.IOException{
  353.             token = lexer.yylex();
  354.             if(token == null)
  355.                     token = new Yytoken(Yytoken.TYPE_EOF, null);
  356.     }
  357.     
  358.     @SuppressWarnings ("rawtypes") private java.util.Map createObjectContainer(ContainerFactory containerFactory){
  359.             if(containerFactory == null)
  360.                     return new org.drip.json.simple.JSONObject();
  361.             java.util.Map m = containerFactory.createObjectContainer();
  362.             
  363.             if(m == null)
  364.                     return new org.drip.json.simple.JSONObject();
  365.             return m;
  366.     }
  367.     
  368.     @SuppressWarnings ("rawtypes") private java.util.List createArrayContainer(ContainerFactory containerFactory){
  369.             if(containerFactory == null)
  370.                     return new org.drip.json.simple.JSONArray();
  371.             java.util.List l = containerFactory.creatArrayContainer();
  372.             
  373.             if(l == null)
  374.                     return new org.drip.json.simple.JSONArray();
  375.             return l;
  376.     }
  377.     
  378.     public void parse(String s, ContentHandler contentHandler) throws ParseException{
  379.             parse(s, contentHandler, false);
  380.     }
  381.     
  382.     public void parse(String s, ContentHandler contentHandler, boolean isResume) throws ParseException{
  383.         java.io.StringReader in=new java.io.StringReader(s);
  384.             try{
  385.                     parse(in, contentHandler, isResume);
  386.             }
  387.             catch(java.io.IOException ie){
  388.                     /*
  389.                      * Actually it will never happen.
  390.                      */
  391.                     throw new ParseException(-1, ParseException.ERROR_UNEXPECTED_EXCEPTION, ie);
  392.             }
  393.     }
  394.     
  395.     public void parse(java.io.Reader in, ContentHandler contentHandler) throws java.io.IOException, ParseException{
  396.             parse(in, contentHandler, false);
  397.     }
  398.     
  399.     /**
  400.      * Stream processing of JSON text.
  401.      * 
  402.      * @see ContentHandler
  403.      * 
  404.      * @param in The Input Reader
  405.      * @param contentHandler The Content Handler Instance
  406.      * @param isResume - Indicates if it continues previous parsing operation.
  407.  *                   If set to true, resume parsing the old stream, and parameter 'in' will be ignored. 
  408.      *                   If this method is called for the first time in this instance, isResume will be ignored.
  409.      * 
  410.      * @throws java.io.IOException Thrown if the Inputs are Invalid
  411.      * 
  412.      * @throws ParseException Thrown if the Inputs are Invalid
  413.      */
  414.     @SuppressWarnings ({"rawtypes", "unchecked"}) public void parse(java.io.Reader in, ContentHandler contentHandler, boolean isResume) throws java.io.IOException, ParseException{
  415.             if(!isResume){
  416.                     reset(in);
  417.                     handlerStatusStack = new java.util.LinkedList();
  418.             }
  419.             else{
  420.                     if(handlerStatusStack == null){
  421.                             isResume = false;
  422.                             reset(in);
  423.                             handlerStatusStack = new java.util.LinkedList();
  424.                     }
  425.             }
  426.             
  427.             java.util.LinkedList statusStack = handlerStatusStack;    
  428.             
  429.             try{
  430.                     do{
  431.                             switch(status){
  432.                             case S_INIT:
  433.                                     contentHandler.startJSON();
  434.                                     nextToken();
  435.                                     switch(token.type){
  436.                                     case Yytoken.TYPE_VALUE:
  437.                                             status=S_IN_FINISHED_VALUE;
  438.                                             statusStack.addFirst(status);
  439.                                             if(!contentHandler.primitive(token.value))
  440.                                                     return;
  441.                                             break;
  442.                                     case Yytoken.TYPE_LEFT_BRACE:
  443.                                             status=S_IN_OBJECT;
  444.                                             statusStack.addFirst(status);
  445.                                             if(!contentHandler.startObject())
  446.                                                     return;
  447.                                             break;
  448.                                     case Yytoken.TYPE_LEFT_SQUARE:
  449.                                             status=S_IN_ARRAY;
  450.                                             statusStack.addFirst(status);
  451.                                             if(!contentHandler.startArray())
  452.                                                     return;
  453.                                             break;
  454.                                     default:
  455.                                             status=S_IN_ERROR;
  456.                                     }//inner switch
  457.                                     break;
  458.                                     
  459.                             case S_IN_FINISHED_VALUE:
  460.                                     nextToken();
  461.                                     if(token.type==Yytoken.TYPE_EOF){
  462.                                             contentHandler.endJSON();
  463.                                             status = S_END;
  464.                                             return;
  465.                                     }
  466.                                     else{
  467.                                             status = S_IN_ERROR;
  468.                                             throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
  469.                                     }
  470.                     
  471.                             case S_IN_OBJECT:
  472.                                     nextToken();
  473.                                     switch(token.type){
  474.                                     case Yytoken.TYPE_COMMA:
  475.                                             break;
  476.                                     case Yytoken.TYPE_VALUE:
  477.                                             if(token.value instanceof String){
  478.                                                     String key=(String)token.value;
  479.                                                     status=S_PASSED_PAIR_KEY;
  480.                                                     statusStack.addFirst(status);
  481.                                                     if(!contentHandler.startObjectEntry(key))
  482.                                                             return;
  483.                                             }
  484.                                             else{
  485.                                                     status=S_IN_ERROR;
  486.                                             }
  487.                                             break;
  488.                                     case Yytoken.TYPE_RIGHT_BRACE:
  489.                                             if(statusStack.size()>1){
  490.                                                     statusStack.removeFirst();
  491.                                                     status=peekStatus(statusStack);
  492.                                             }
  493.                                             else{
  494.                                                     status=S_IN_FINISHED_VALUE;
  495.                                             }
  496.                                             if(!contentHandler.endObject())
  497.                                                     return;
  498.                                             break;
  499.                                     default:
  500.                                             status=S_IN_ERROR;
  501.                                             break;
  502.                                     }//inner switch
  503.                                     break;
  504.                                     
  505.                             case S_PASSED_PAIR_KEY:
  506.                                     nextToken();
  507.                                     switch(token.type){
  508.                                     case Yytoken.TYPE_COLON:
  509.                                             break;
  510.                                     case Yytoken.TYPE_VALUE:
  511.                                             statusStack.removeFirst();
  512.                                             status=peekStatus(statusStack);
  513.                                             if(!contentHandler.primitive(token.value))
  514.                                                     return;
  515.                                             if(!contentHandler.endObjectEntry())
  516.                                                     return;
  517.                                             break;
  518.                                     case Yytoken.TYPE_LEFT_SQUARE:
  519.                                             statusStack.removeFirst();
  520.                                             statusStack.addFirst(S_IN_PAIR_VALUE);
  521.                                             status=S_IN_ARRAY;
  522.                                             statusStack.addFirst(status);
  523.                                             if(!contentHandler.startArray())
  524.                                                     return;
  525.                                             break;
  526.                                     case Yytoken.TYPE_LEFT_BRACE:
  527.                                             statusStack.removeFirst();
  528.                                             statusStack.addFirst(S_IN_PAIR_VALUE);
  529.                                             status=S_IN_OBJECT;
  530.                                             statusStack.addFirst(status);
  531.                                             if(!contentHandler.startObject())
  532.                                                     return;
  533.                                             break;
  534.                                     default:
  535.                                             status=S_IN_ERROR;
  536.                                     }
  537.                                     break;
  538.                             
  539.                             case S_IN_PAIR_VALUE:
  540.                                     /*
  541.                                      * S_IN_PAIR_VALUE is just a marker to indicate the end of an object entry, it doesn't proccess any token,
  542.                                      * therefore delay consuming token until next round.
  543.                                      */
  544.                                     statusStack.removeFirst();
  545.                                     status = peekStatus(statusStack);
  546.                                     if(!contentHandler.endObjectEntry())
  547.                                             return;
  548.                                     break;
  549.                                     
  550.                             case S_IN_ARRAY:
  551.                                     nextToken();
  552.                                     switch(token.type){
  553.                                     case Yytoken.TYPE_COMMA:
  554.                                             break;
  555.                                     case Yytoken.TYPE_VALUE:
  556.                                             if(!contentHandler.primitive(token.value))
  557.                                                     return;
  558.                                             break;
  559.                                     case Yytoken.TYPE_RIGHT_SQUARE:
  560.                                             if(statusStack.size()>1){
  561.                                                     statusStack.removeFirst();
  562.                                                     status=peekStatus(statusStack);
  563.                                             }
  564.                                             else{
  565.                                                     status=S_IN_FINISHED_VALUE;
  566.                                             }
  567.                                             if(!contentHandler.endArray())
  568.                                                     return;
  569.                                             break;
  570.                                     case Yytoken.TYPE_LEFT_BRACE:
  571.                                             status=S_IN_OBJECT;
  572.                                             statusStack.addFirst(status);
  573.                                             if(!contentHandler.startObject())
  574.                                                     return;
  575.                                             break;
  576.                                     case Yytoken.TYPE_LEFT_SQUARE:
  577.                                             status=S_IN_ARRAY;
  578.                                             statusStack.addFirst(status);
  579.                                             if(!contentHandler.startArray())
  580.                                                     return;
  581.                                             break;
  582.                                     default:
  583.                                             status=S_IN_ERROR;
  584.                                     }//inner switch
  585.                                     break;
  586.                                     
  587.                             case S_END:
  588.                                     return;
  589.                                     
  590.                             case S_IN_ERROR:
  591.                                     throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
  592.                             }//switch
  593.                             if(status==S_IN_ERROR){
  594.                                     throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
  595.                             }
  596.                     }while(token.type!=Yytoken.TYPE_EOF);
  597.             }
  598.             catch(java.io.IOException ie){
  599.                     status = S_IN_ERROR;
  600.                     throw ie;
  601.             }
  602.             catch(ParseException pe){
  603.                     status = S_IN_ERROR;
  604.                     throw pe;
  605.             }
  606.             catch(RuntimeException re){
  607.                     status = S_IN_ERROR;
  608.                     throw re;
  609.             }
  610.             catch(Error e){
  611.                     status = S_IN_ERROR;
  612.                     throw e;
  613.             }
  614.             
  615.             status = S_IN_ERROR;
  616.             throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
  617.     }
  618. }
Created with JaCoCo 0.7.9.201702052155