From 2eb9b19e61a66af374019d5db20466b050b3a95b Mon Sep 17 00:00:00 2001
From: yaokai13 <yaokai13@huawei.com>
Date: Tue, 25 Aug 2020 19:13:48 +0800
Subject: [PATCH] package init

---
 0001-Add-pre-generated-Java-classes.patch | 2182 +++++++++++++++++++++
 1.3.0.Final.tar.gz                        |  Bin 0 -> 46266 bytes
 jboss-dmr.spec                            |   41 +
 jboss-dmr.yaml                            |    4 +
 4 files changed, 2227 insertions(+)
 create mode 100644 0001-Add-pre-generated-Java-classes.patch
 create mode 100644 1.3.0.Final.tar.gz
 create mode 100644 jboss-dmr.spec
 create mode 100644 jboss-dmr.yaml

diff --git a/0001-Add-pre-generated-Java-classes.patch b/0001-Add-pre-generated-Java-classes.patch
new file mode 100644
index 0000000..9d814ea
--- /dev/null
+++ b/0001-Add-pre-generated-Java-classes.patch
@@ -0,0 +1,2182 @@
+From 8c60f8b062e64cf6bbe396923b4e42c02624bf6f Mon Sep 17 00:00:00 2001
+From: gil <puntogil@libero.it>
+Date: Fri, 27 May 2016 16:16:21 +0200
+Subject: [PATCH] Add pre-generated Java classes
+
+---
+ src/main/java/org/jboss/dmr/JSONParser.java | 1042 +++++++++++++++++++++++++
+ src/main/java/org/jboss/dmr/Parser.java     | 1113 +++++++++++++++++++++++++++
+ 2 files changed, 2155 insertions(+)
+ create mode 100644 src/main/java/org/jboss/dmr/JSONParser.java
+ create mode 100644 src/main/java/org/jboss/dmr/Parser.java
+
+diff --git a/src/main/java/org/jboss/dmr/JSONParser.java b/src/main/java/org/jboss/dmr/JSONParser.java
+new file mode 100644
+index 0000000..a59782f
+--- /dev/null
++++ b/src/main/java/org/jboss/dmr/JSONParser.java
+@@ -0,0 +1,1042 @@
++/*
++ * JBoss, Home of Professional Open Source.
++ * Copyright 2011, Red Hat, Inc., and individual contributors
++ * as indicated by the @author tags. See the copyright.txt file in the
++ * distribution for a full listing of individual contributors.
++ *
++ * This is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License as
++ * published by the Free Software Foundation; either version 2.1 of
++ * the License, or (at your option) any later version.
++ *
++ * This software is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public
++ * License along with this software; if not, write to the Free
++ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
++ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
++ */
++package org.jboss.dmr;
++
++import java.io.IOException;
++import java.io.InputStream;
++
++import java.util.LinkedList;
++import java.util.Vector;
++import java.util.Stack;
++
++public abstract class JSONParser
++{
++	protected final static int OPEN_BRACE = 256;
++	protected final static int CLOSE_BRACE = 257;
++	protected final static int OPEN_BRACKET = 258;
++	protected final static int CLOSE_BRACKET = 259;
++	protected final static int COLON = 260;
++	protected final static int COMMA = 261;
++	protected final static int BIG = 262;
++	protected final static int INTEGER = 263;
++	protected final static int DECIMAL = 264;
++	protected final static int UNDEFINED = 265;
++	protected final static int TRUE = 266;
++	protected final static int FALSE = 267;
++	protected final static int ZERO_VAL = 268;
++	protected final static int OCTAL_INT_VAL = 269;
++	protected final static int HEX_INT_VAL = 270;
++	protected final static int SIGNED_HEX_INT_VAL = 271;
++	protected final static int DEC_INT_VAL = 272;
++	protected final static int NAN_VAL = 273;
++	protected final static int INF_VAL = 274;
++	protected final static int DEC_VAL = 275;
++	protected final static int STR_VAL = 276;
++
++	protected final static int INITIAL = 0;
++
++	// an internal class for lazy initiation
++	private final static class cc_lexer
++	{
++		private static char[] accept = ("\000\027\026\027\005\027\015\021\006\027\027\003\004\027\027\027\027\027\027\001\002\030\000\025\000\015\000\000\000\015\016\000\000\000\000\000\000\000\000\000\000\024\017\000\022\011\000\000\000\000\000\020\000\000\000\000\000\014\007\000\024\000\000\010\000\000\000\000\000\012\013\023").toCharArray ();
++		private static char[] ecs = ("\000\000\000\000\000\000\000\000\000\001\002\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\003\000\000\000\000\000\000\000\000\000\004\005\006\000\007\010\010\010\010\010\010\010\010\010\011\000\000\000\000\000\000\012\012\012\012\013\012\000\000\014\000\000\000\000\015\000\000\000\000\000\000\000\000\000\000\000\000\016\017\020\000\000\000\021\022\023\024\025\026\027\000\030\000\000\031\032\033\000\000\000\034\035\036\037\000\000\040\041\000\042\000\043\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\044").toCharArray ();
++		private static char[] base = ("\065\000\003\000\000\047\000\014\000\002\005\000\000\014\022\037\026\023\076\000\000\000\000\000\000\073\000\000\002\074\005\006\107\121\110\115\110\104\112\105\027\000\000\115\000\000\116\112\123\120\125\000\036\120\122\130\127\000\000\152\000\130\140\000\135\125\133\131\125\000\000\000\167\000\171").toCharArray ();
++		private static char[] next = ("\026\000\026\027\002\002\034\035\036\051\051\064\036\052\052\030\052\052\034\007\007\064\041\052\052\052\052\052\052\040\063\063\037\063\063\073\042\074\074\043\063\063\063\063\063\063\031\007\044\045\046\032\033\001\002\002\003\004\005\001\006\007\010\001\001\011\012\013\001\014\001\015\001\016\001\017\001\020\001\001\021\001\001\022\001\001\001\023\024\025\047\050\000\053\054\055\056\057\060\061\062\065\066\067\070\071\072\075\076\077\100\000\101\102\103\104\105\106\107\026\026\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000").toCharArray ();
++		private static char[] check = ("\111\112\111\003\002\002\006\006\006\034\034\051\036\037\037\003\037\037\007\007\007\051\012\037\037\037\037\037\037\011\050\050\006\050\050\064\015\064\064\016\050\050\050\050\050\050\005\005\017\020\021\005\005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\022\031\035\040\041\042\043\044\045\046\047\053\056\057\060\061\062\065\066\067\070\073\075\076\100\101\102\103\104\110\110\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112").toCharArray ();
++		private static char[] defaults = ("\112\112\001\110\112\001\001\001\112\001\001\112\112\001\001\001\001\001\001\112\112\112\003\112\111\006\011\012\001\006\035\001\001\001\001\001\001\001\001\001\001\034\037\001\112\112\001\001\001\001\001\050\001\001\001\001\001\112\112\064\073\001\001\112\001\001\001\001\001\112\112\112\112\112\112").toCharArray ();
++		private static char[] meta = ("\000\000\001\002\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003").toCharArray ();
++	}
++
++	// an internal class for lazy initiation
++	private final static class cc_parser
++	{
++		private static char[] rule = ("\000\001\001\001\001\001\001\001\001\001\001\001\001\002\002\003\002\002\003\001\001\002\003\004\005").toCharArray ();
++		private static char[] ecs = ("\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\003\004\005\006\007\000\000\000\010\011\012\013\014\015\016\017\020\021\022\023").toCharArray ();
++		private static char[] base = ("\016\160\006\000\042\043\053\054\064\065\075\076\106\107\117\002\014\001\151\120\011\130\160\131\020\141\001\000\142\177\152\036\007\000\012\u0087\u0092\u009c\u0096\u009c\u009c\u009c\u009c\u009c\u009c\u009c\u009c\u009c\u009c\u009c\u009c\u009c\u009c\u009c\u009c\u009c\u009c\u009c\u009c\u009c\u0097\u009c\u009c\u0098\u009c\u009c\u009c\u009c\u009c\u0099\u009c\u009c").toCharArray ();
++		private static char[] next = ("\uffec\000\uffff\uffec\036\uffec\027\uffec\030\000\uffe9\025\ufffe\uffe8\uffe9\033\001\uffe8\002\000\037\034\003\004\005\006\007\010\011\012\013\014\015\016\ufff5\ufff4\041\ufff5\ufff4\ufff5\ufff4\ufff5\ufff4\ufffd\ufff8\000\ufffd\ufff8\ufffd\ufff8\ufffd\ufff8\ufff7\ufff6\000\ufff7\ufff6\ufff7\ufff6\ufff7\ufff6\ufff9\ufffb\000\ufff9\ufffb\ufff9\ufffb\ufff9\ufffb\ufffa\ufffc\000\ufffa\ufffc\ufffa\ufffc\ufffa\ufffc\uffed\ufff0\000\uffed\ufff0\uffed\ufff0\uffed\ufff0\ufff3\ufff2\000\ufff3\ufff2\ufff3\ufff2\ufff3\ufff2\uffef\ufff1\000\uffef\ufff1\uffef\ufff1\uffef\ufff1\uffee\000\031\uffee\000\uffee\032\uffee\000\023\000\uffeb\000\uffeb\000\000\000\000\000\000\000\000\000\000\000\024\uffea\000\uffea\000\000\000\000\000\000\000\000\000\000\000\000\017\020\021\022\000\026\035\040\042\000\000\000\000\000").toCharArray ();
++		private static char[] check = ("\003\021\017\003\032\003\021\003\021\024\040\002\020\042\040\024\000\042\000\003\032\030\000\000\000\000\000\000\000\000\000\000\000\000\004\005\037\004\005\004\005\004\005\006\007\043\006\007\006\007\006\007\010\011\043\010\011\010\011\010\011\012\013\043\012\013\012\013\012\013\014\015\043\014\015\014\015\014\015\016\023\043\016\023\016\023\016\023\025\027\043\025\027\025\027\025\027\031\034\043\031\034\031\034\031\034\036\043\022\036\022\036\022\036\001\001\001\026\043\026\001\001\001\001\001\001\001\001\001\001\001\001\035\043\035\043\043\043\043\043\043\043\043\043\043\043\043\044\044\044\044\046\046\074\077\105\107\107\107\107\107").toCharArray ();
++		private static char[] defaults = ("\043\000\000\001\003\003\003\003\003\003\003\003\003\003\003\043\017\017\021\003\017\003\021\003\000\003\001\000\003\021\003\024\022\000\022\043").toCharArray ();
++		private static char[] gotoDefault = ("\107\107\044\107\107\107\107\107\107\107\107\107\107\107\107\107\107\107\107\107\107\107\107\107\046\107\107\046\107\107\107\107\107\046\107\107").toCharArray ();
++		private static char[] lhs = ("\000\024\025\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\027\027\030\030").toCharArray ();
++	}
++
++	private final static class YYParserState	// internal tracking tool
++	{
++		int token;			// the current token type
++		Object value;		// the current value associated with token
++		int state;			// the current scan state
++
++		YYParserState ()	// EOF token construction
++		{
++			this (0, null, 0);
++		}
++		YYParserState (int token)
++		{
++			this (token, null, 0);
++		}
++		YYParserState (int token, Object value)
++		{
++			this (token, value, 0);
++		}
++		YYParserState (int token, Object value, int state)
++		{
++			this.token = token;
++			this.value = value;
++			this.state = state;
++		}
++	}
++
++	// lookahead stack for the parser
++	private final LinkedList _yyLookaheadStack = new LinkedList ();
++	// state stack for the parser
++	private final Vector _yyStateStack = new Vector (512, 512);
++	// flag that indicates error
++	private boolean _yyInError;
++	// internal track of the argument start
++	private int _yyArgStart;
++	// for passing value from lexer to parser
++	private Object _yyValue;
++
++	private InputStream _yyIs = System.in;
++	private byte[] _yyBuffer;
++	private int _yyBufferSize = 4096;
++	private int _yyMatchStart;
++	private int _yyBufferEnd;
++
++	private int _yyBaseState;
++
++	private int _yyTextStart;
++	private int _yyLength;
++
++	private Stack _yyLexerStack;
++	private Stack _yyInputStack;
++
++
++	/**
++	 * Set the current input.
++	 *
++	 * @param	is
++	 *			the new input.
++	 */
++	public void setInput (InputStream is)
++	{
++		_yyIs = is;
++	}
++
++	/**
++	 * Obtain the current input.
++	 *
++	 * @return	the current input
++	 */
++	public InputStream getInput ()
++	{
++		return _yyIs;
++	}
++
++	/**
++	 * Switch the current input to the new input.  The old input and already
++	 * buffered characters are pushed onto the stack.
++	 *
++	 * @param	is
++	 * 			the new input
++	 */
++	public void yyPushInput (InputStream is)
++	{
++		int len = _yyBufferEnd - _yyMatchStart;
++		byte[] leftOver = new byte[len];
++		System.arraycopy (_yyBuffer, _yyMatchStart, leftOver, 0, len);
++
++		Object[] states = new Object[4];
++		states[0] = _yyIs;
++		states[1] = leftOver;
++
++		if (_yyInputStack == null)
++			_yyInputStack = new Stack ();
++		_yyInputStack.push (states);
++
++		_yyIs = is;
++		_yyMatchStart = 0;
++		_yyBufferEnd = 0;
++	}
++
++	/**
++	 * Switch the current input to the old input on stack.  The currently
++	 * buffered characters are inserted infront of the old buffered characters.
++	 */
++	public void yyPopInput ()
++	{
++		Object[] states = (Object[])_yyInputStack.pop ();
++		_yyIs = (InputStream)states[0];
++		byte[] leftOver = (byte[])states[1];
++
++		int curLen = _yyBufferEnd - _yyMatchStart;
++
++		if ((leftOver.length + curLen) > _yyBuffer.length)
++		{
++			byte[] newBuffer = new byte[leftOver.length + curLen];
++			System.arraycopy (_yyBuffer, _yyMatchStart, newBuffer, 0, curLen);
++			System.arraycopy (leftOver, 0, newBuffer, curLen, leftOver.length);
++			_yyBuffer = newBuffer;
++			_yyMatchStart = 0;
++			_yyBufferEnd = leftOver.length + curLen;
++		}
++		else
++		{
++			int start = _yyMatchStart;
++			int end = _yyBufferEnd;
++			byte[] buffer = _yyBuffer;
++
++			for (int i = 0; start < end; ++i, ++start)
++				buffer[i] = buffer[start];
++			System.arraycopy (leftOver, 0, buffer, curLen, leftOver.length);
++			_yyMatchStart = 0;
++			_yyBufferEnd = leftOver.length + curLen;
++		}
++	}
++
++	/**
++	 * Obtain the number of input objects on the stack.
++	 *
++	 * @return	the number of input objects on the stack.
++	 */
++	public int yyInputStackSize ()
++	{
++		return _yyInputStack == null ? 0 : _yyInputStack.size ();
++	}
++
++
++	/**
++	 * Get the current token text.
++	 * <p>
++	 * Avoid calling this function unless it is absolutely necessary since it creates
++	 * a copy of the token string.  The string length can be found by reading _yyLength
++	 * or calling yyLength () function.
++	 *
++	 * @return	the current text token.
++	 */
++	public String yyText ()
++	{
++		if (_yyMatchStart == _yyTextStart)		// this is the case when we have EOF
++			return null;
++		return new String (_yyBuffer, _yyTextStart, _yyMatchStart - _yyTextStart);
++	}
++
++	/**
++	 * Get the current text token's length.  Actions specified in the CookCC file
++	 * can directly access the variable _yyLength.
++	 *
++	 * @return	the string token length
++	 */
++	public int yyLength ()
++	{
++		return _yyLength;
++	}
++
++	/**
++	 * Print the current string token to the standard output.
++	 */
++	public void echo ()
++	{
++		System.out.print (yyText ());
++	}
++
++	/**
++	 * Put all but n characters back to the input stream.  Be aware that calling
++	 * yyLess (0) is allowed, but be sure to change the state some how to avoid
++	 * an endless loop.
++	 *
++	 * @param	n
++	 * 			The number of characters.
++	 */
++	protected void yyLess (int n)
++	{
++		if (n < 0)
++			throw new IllegalArgumentException ("yyLess function requires a non-zero value.");
++		if (n > (_yyMatchStart - _yyTextStart))
++			throw new IndexOutOfBoundsException ("yyLess function called with a too large index value " + n + ".");
++		_yyMatchStart = _yyTextStart + n;
++	}
++
++	/**
++	 * Set the lexer's current state.
++	 *
++	 * @param	baseState
++	 *			the base state index
++	 */
++	protected void begin (int baseState)
++	{
++		_yyBaseState = baseState;
++	}
++
++	/**
++	 * Push the current state onto lexer state onto stack and
++	 * begin the new state specified by the user.
++	 *
++	 * @param	newState
++	 *			the new state.
++	 */
++	protected void yyPushLexerState (int newState)
++	{
++		if (_yyLexerStack == null)
++			_yyLexerStack = new Stack ();
++		_yyLexerStack.push (new Integer (_yyBaseState));
++		begin (newState);
++	}
++
++	/**
++	 * Restore the previous lexer state.
++	 */
++	protected void yyPopLexerState ()
++	{
++		begin (((Integer)_yyLexerStack.pop ()).intValue ());
++	}
++
++
++	// read more data from the input
++	protected boolean yyRefreshBuffer () throws IOException
++	{
++		if (_yyBuffer == null)
++			_yyBuffer = new byte[_yyBufferSize];
++		if (_yyMatchStart > 0)
++		{
++			if (_yyBufferEnd > _yyMatchStart)
++			{
++				System.arraycopy (_yyBuffer, _yyMatchStart, _yyBuffer, 0, _yyBufferEnd - _yyMatchStart);
++				_yyBufferEnd -= _yyMatchStart;
++				_yyMatchStart = 0;
++			}
++			else
++			{
++				_yyMatchStart = 0;
++				_yyBufferEnd = 0;
++			}
++		}
++		else if (_yyBufferEnd == _yyBuffer.length)
++		{
++			byte[] newBuffer = new byte[_yyBuffer.length + _yyBuffer.length / 2];
++			System.arraycopy (_yyBuffer, 0, newBuffer, 0, _yyBufferEnd);
++			_yyBuffer = newBuffer;
++		}
++
++		int readSize = _yyIs.read (_yyBuffer, _yyBufferEnd, _yyBuffer.length - _yyBufferEnd);
++		if (readSize > 0)
++			_yyBufferEnd += readSize;
++		else if (readSize < 0 && !yyWrap ())		// since we are at EOF, call yyWrap ().  If the return value of yyWrap is false, refresh buffer again
++			return yyRefreshBuffer ();
++		return readSize >= 0;
++	}
++
++	/**
++	 * Reset the internal buffer.
++	 */
++	public void yyResetBuffer ()
++	{
++		_yyMatchStart = 0;
++		_yyBufferEnd = 0;
++	}
++
++	/**
++	 * Set the internal buffer size.  This action can only be performed
++	 * when the buffer is empty.  Having a large buffer is useful to read
++	 * a whole file in to increase the performance sometimes.
++	 *
++	 * @param	bufferSize
++	 *			the new buffer size.
++	 */
++	public void setBufferSize (int bufferSize)
++	{
++		if (_yyBufferEnd > _yyMatchStart)
++			throw new IllegalArgumentException ("Cannot change lexer buffer size at this moment.");
++		_yyBufferSize = bufferSize;
++		_yyMatchStart = 0;
++		_yyBufferEnd = 0;
++		if (_yyBuffer != null && bufferSize != _yyBuffer.length)
++			_yyBuffer = new byte[bufferSize];
++	}
++
++	/**
++	 * Call this function to start the scanning of the input.
++	 *
++	 * @return	a token or status value.
++	 * @throws	IOException
++	 *			in case of I/O error.
++	 */
++	protected int yyLex () throws IOException
++	{
++
++		char[] cc_ecs = cc_lexer.ecs;
++		char[] cc_next = cc_lexer.next;
++		char[] cc_check = cc_lexer.check;
++		char[] cc_base = cc_lexer.base;
++		char[] cc_default = cc_lexer.defaults;
++		char[] cc_meta = cc_lexer.meta;
++		char[] cc_accept = cc_lexer.accept;
++
++		byte[] buffer = _yyBuffer;
++
++		while (true)
++		{
++			// initiate variables necessary for lookup
++			int cc_matchedState = _yyBaseState;
++
++			int matchedLength = 0;
++
++			int internalBufferEnd = _yyBufferEnd;
++			int lookahead = _yyMatchStart;
++
++			int cc_backupMatchedState = cc_matchedState;
++			int cc_backupMatchedLength = 0;
++
++			// the DFA lookup
++			while (true)
++			{
++				// check buffer status
++				if (lookahead < internalBufferEnd)
++				{
++					// now okay to process the character
++					int cc_toState;
++					int symbol = cc_ecs[buffer[lookahead] & 0xff];
++					cc_toState = cc_matchedState;
++					while (cc_check[symbol + cc_base[cc_toState]] != cc_toState)
++					{
++						cc_toState = cc_default[cc_toState];
++						if (cc_toState >= 72)
++							symbol = cc_meta[symbol];
++					}
++					cc_toState = cc_next[symbol + cc_base[cc_toState]];
++
++					if (cc_toState == 0)
++					{
++						cc_matchedState = cc_backupMatchedState;
++						matchedLength = cc_backupMatchedLength;
++						break;
++					}
++
++					cc_matchedState = cc_toState;
++					++lookahead;
++					++matchedLength;
++
++					if (cc_accept[cc_matchedState] > 0)
++					{
++						cc_backupMatchedState = cc_toState;
++						cc_backupMatchedLength = matchedLength;
++					}
++				}
++				else
++				{
++					int lookPos = lookahead - _yyMatchStart;
++					boolean refresh = yyRefreshBuffer ();
++					buffer = _yyBuffer;
++					internalBufferEnd = _yyBufferEnd;
++					lookahead = _yyMatchStart + lookPos;
++					if (! refresh)
++					{
++						// <<EOF>>
++						int cc_toState;
++						int symbol = cc_ecs[256];
++						cc_toState = cc_matchedState;
++						while (cc_check[symbol + cc_base[cc_toState]] != cc_toState)
++						{
++							cc_toState = cc_default[cc_toState];
++							if (cc_toState >= 72)
++								symbol = cc_meta[symbol];
++						}
++						cc_toState = cc_next[symbol + cc_base[cc_toState]];
++
++						if (cc_toState != 0)
++							cc_matchedState = cc_toState;
++						else
++						{
++							cc_matchedState = cc_backupMatchedState;
++							matchedLength = cc_backupMatchedLength;
++						}
++						break;
++					}
++				}
++			}
++
++			_yyTextStart = _yyMatchStart;
++			_yyMatchStart += matchedLength;
++			_yyLength = matchedLength;
++
++
++			switch (cc_accept[cc_matchedState])
++			{
++				case 1:	// \{
++				{
++					_yyValue = m_this.parseToken (); return OPEN_BRACE;
++				}
++				case 28: break;
++				case 2:	// \}
++				{
++					_yyValue = m_this.parseToken (); return CLOSE_BRACE;
++				}
++				case 29: break;
++				case 3:	// \[
++				{
++					_yyValue = m_this.parseToken (); return OPEN_BRACKET;
++				}
++				case 30: break;
++				case 4:	// \]
++				{
++					_yyValue = m_this.parseToken (); return CLOSE_BRACKET;
++				}
++				case 31: break;
++				case 5:	// ,
++				{
++					_yyValue = m_this.parseToken (); return COMMA;
++				}
++				case 32: break;
++				case 6:	// :
++				{
++					_yyValue = m_this.parseToken (); return COLON;
++				}
++				case 33: break;
++				case 7:	// true
++				{
++					_yyValue = m_this.parseToken (); return TRUE;
++				}
++				case 34: break;
++				case 8:	// false
++				{
++					_yyValue = m_this.parseToken (); return FALSE;
++				}
++				case 35: break;
++				case 9:	// big
++				{
++					_yyValue = m_this.parseToken (); return BIG;
++				}
++				case 36: break;
++				case 10:	// decimal
++				{
++					_yyValue = m_this.parseToken (); return DECIMAL;
++				}
++				case 37: break;
++				case 11:	// integer
++				{
++					_yyValue = m_this.parseToken (); return INTEGER;
++				}
++				case 38: break;
++				case 12:	// null
++				{
++					_yyValue = m_this.parseToken (); return UNDEFINED;
++				}
++				case 39: break;
++				case 13:	// [+-]?0+
++				{
++					_yyValue = m_this.parsePlainValue (); return ZERO_VAL;
++				}
++				case 40: break;
++				case 14:	// [+-]?0[0-9]+
++				{
++					_yyValue = m_this.parsePlainValue (); return OCTAL_INT_VAL;
++				}
++				case 41: break;
++				case 15:	// 0x[0-9a-fA-F]+
++				{
++					_yyValue = m_this.parsePlainValue (); return HEX_INT_VAL;
++				}
++				case 42: break;
++				case 16:	// [+-]0x[0-9a-fA-F]+
++				{
++					_yyValue = m_this.parsePlainValue (); return SIGNED_HEX_INT_VAL;
++				}
++				case 43: break;
++				case 17:	// [+-]?[1-9][0-9]*
++				{
++					_yyValue = m_this.parsePlainValue (); return DEC_INT_VAL;
++				}
++				case 44: break;
++				case 18:	// [+-]?NaN
++				{
++					_yyValue = m_this.parsePlainValue (); return NAN_VAL;
++				}
++				case 45: break;
++				case 19:	// [+-]?Infinity
++				{
++					_yyValue = m_this.parsePlainValue (); return INF_VAL;
++				}
++				case 46: break;
++				case 20:	// [+-]?([0-9]+\.[0-9]+([eE][+-]?[0-9]+)?)
++				{
++					_yyValue = m_this.parsePlainValue (); return DEC_VAL;
++				}
++				case 47: break;
++				case 21:	// \"([^"\\]+|\\.)*\"
++				{
++					_yyValue = m_this.parseStringValue (); return STR_VAL;
++				}
++				case 48: break;
++				case 22:	// [ \t\r\n]+
++				{
++					m_this.ignored ();
++				}
++				case 49: break;
++				case 23:	// .
++				{
++					m_this.invalid ();
++				}
++				case 50: break;
++				case 24:	// <<EOF>>
++				{
++					m_this.parseEOF (); return 0;
++				}
++				case 51: break;
++				case 25:	// .|\n
++				{
++					echo ();			// default character action
++				}
++				case 52: break;
++				case 26:	// <<EOF>>
++				{
++					return 0;			// default EOF action
++				}
++				case 53: break;
++				default:
++					throw new IOException ("Internal error in JSONParser lexer.");
++			}
++
++		}
++	}
++
++
++	/**
++	 * Call this function to start parsing.
++	 *
++	 * @return	0 if everything is okay, or 1 if an error occurred.
++	 * @throws	IOException
++	 *			in case of error
++	 */
++	public int yyParse () throws IOException
++	{
++		char[] cc_ecs = cc_parser.ecs;
++		char[] cc_next = cc_parser.next;
++		char[] cc_check = cc_parser.check;
++		char[] cc_base = cc_parser.base;
++		char[] cc_default = cc_parser.defaults;
++		char[] cc_gotoDefault = cc_parser.gotoDefault;
++		char[] cc_rule = cc_parser.rule;
++		char[] cc_lhs = cc_parser.lhs;
++
++		LinkedList cc_lookaheadStack = _yyLookaheadStack;
++		Vector cc_stateStack = _yyStateStack;
++
++		if (cc_stateStack.size () == 0)
++			cc_stateStack.add (new YYParserState ());
++
++		int cc_toState = 0;
++
++		for (;;)
++		{
++			YYParserState cc_lookahead;
++
++			int cc_fromState;
++			char cc_ch;
++
++			//
++			// check if there are any lookahead tokens on stack
++			// if not, then call yyLex ()
++			//
++			if (cc_lookaheadStack.size () == 0)
++			{
++				_yyValue = null;
++				int val = yyLex ();
++				cc_lookahead = new YYParserState (val, _yyValue);
++				cc_lookaheadStack.add (cc_lookahead);
++			}
++			else
++				cc_lookahead = (YYParserState)cc_lookaheadStack.getLast ();
++
++			cc_ch = cc_ecs[cc_lookahead.token];
++			cc_fromState = ((YYParserState)cc_stateStack.get (cc_stateStack.size () - 1)).state;
++			int cc_symbol = cc_ch;
++			cc_toState = cc_fromState;
++			while (cc_check[cc_symbol + cc_base[cc_toState]] != cc_toState)
++			{
++				cc_toState = cc_default[cc_toState];
++				if (cc_toState >= 35)
++					cc_symbol = 0;
++			}
++			cc_toState = (short)cc_next[cc_symbol + cc_base[cc_toState]];
++
++
++			//
++			// check the value of toState and determine what to do
++			// with it
++			//
++			if (cc_toState > 0)
++			{
++				// shift
++				cc_lookahead.state = cc_toState;
++				cc_stateStack.add (cc_lookahead);
++				cc_lookaheadStack.removeLast ();
++				continue;
++			}
++			else if (cc_toState == 0)
++			{
++				// error
++				if (_yyInError)
++				{
++					// first check if the error is at the lookahead
++					if (cc_ch == 1)
++					{
++						// so we need to reduce the stack until a state with reduceable
++						// action is found
++						if (_yyStateStack.size () > 1)
++							_yyStateStack.setSize (_yyStateStack.size () - 1);
++						else
++							return 1;	// can't do much we exit the parser
++					}
++					else
++					{
++						// this means that we need to dump the lookahead.
++						if (cc_ch == 0)		// can't do much with EOF;
++							return 1;
++						cc_lookaheadStack.removeLast ();
++					}
++					continue;
++				}
++				else
++				{
++					if (yyParseError (cc_lookahead.token))
++						return 1;
++					_yyLookaheadStack.add (new YYParserState (1, _yyValue));
++					_yyInError = true;
++					continue;
++				}
++			}
++			_yyInError = false;
++			// now the reduce action
++			int cc_ruleState = -cc_toState;
++
++			_yyArgStart = cc_stateStack.size () - cc_rule[cc_ruleState] - 1;
++			//
++			// find the state that said need this non-terminal
++			//
++			cc_fromState = ((YYParserState)cc_stateStack.get (_yyArgStart)).state;
++
++			//
++			// find the state to goto after shifting the non-terminal
++			// onto the stack.
++			//
++			if (cc_ruleState == 1)
++				cc_toState = 0;			// reset the parser
++			else
++			{
++				cc_toState = cc_fromState + 36;
++				int cc_tmpCh = cc_lhs[cc_ruleState] - 20;
++				while (cc_check[cc_tmpCh + cc_base[cc_toState]] != cc_toState)
++					cc_toState = cc_gotoDefault[cc_toState - 36];
++				cc_toState = cc_next[cc_tmpCh + cc_base[cc_toState]];
++			}
++
++			_yyValue = null;
++
++			switch (cc_ruleState)
++			{
++				case 1:					// accept
++					return 0;
++				case 2:	// complete : node
++				{
++					return m_this.parse ((org.jboss.dmr.ModelNode)yyGetValue (1));
++				}
++				case 27: break;
++				case 3:	// node : ZERO_VAL
++				{
++					_yyValue = m_this.parseZero ();
++				}
++				case 28: break;
++				case 4:	// node : DEC_VAL
++				{
++					_yyValue = m_this.parseBigDecimal ((java.lang.String)yyGetValue (1));
++				}
++				case 29: break;
++				case 5:	// node : NAN_VAL
++				{
++					_yyValue = m_this.parseNaN ();
++				}
++				case 30: break;
++				case 6:	// node : INF_VAL
++				{
++					_yyValue = m_this.parseInf ((java.lang.String)yyGetValue (1));
++				}
++				case 31: break;
++				case 7:	// node : DEC_INT_VAL
++				{
++					_yyValue = m_this.parseDecInt ((java.lang.String)yyGetValue (1));
++				}
++				case 32: break;
++				case 8:	// node : OCTAL_INT_VAL
++				{
++					_yyValue = m_this.parseOctal ((java.lang.String)yyGetValue (1));
++				}
++				case 33: break;
++				case 9:	// node : HEX_INT_VAL
++				{
++					_yyValue = m_this.parseHex ((java.lang.String)yyGetValue (1));
++				}
++				case 34: break;
++				case 10:	// node : SIGNED_HEX_INT_VAL
++				{
++					_yyValue = m_this.parseHexSigned ((java.lang.String)yyGetValue (1));
++				}
++				case 35: break;
++				case 11:	// node : TRUE
++				{
++					_yyValue = m_this.parseTrue ();
++				}
++				case 36: break;
++				case 12:	// node : FALSE
++				{
++					_yyValue = m_this.parseFalse ();
++				}
++				case 37: break;
++				case 13:	// node : OPEN_BRACKET CLOSE_BRACKET
++				{
++					_yyValue = m_this.parseEmptyList ();
++				}
++				case 38: break;
++				case 14:	// node : list CLOSE_BRACKET
++				{
++					_yyValue = m_this.finishList ((org.jboss.dmr.ModelNode)yyGetValue (1));
++				}
++				case 39: break;
++				case 15:	// node : list COMMA CLOSE_BRACKET
++				{
++					_yyValue = m_this.finishList ((org.jboss.dmr.ModelNode)yyGetValue (1));
++				}
++				case 40: break;
++				case 16:	// node : OPEN_BRACE CLOSE_BRACE
++				{
++					_yyValue = m_this.parseEmptyObject ();
++				}
++				case 41: break;
++				case 17:	// node : object CLOSE_BRACE
++				{
++					_yyValue = m_this.finishObject ((org.jboss.dmr.ModelNode)yyGetValue (1));
++				}
++				case 42: break;
++				case 18:	// node : object COMMA CLOSE_BRACE
++				{
++					_yyValue = m_this.finishObject ((org.jboss.dmr.ModelNode)yyGetValue (1));
++				}
++				case 43: break;
++				case 19:	// node : STR_VAL
++				{
++					_yyValue = m_this.parseString ((java.lang.String)yyGetValue (1));
++				}
++				case 44: break;
++				case 20:	// node : UNDEFINED
++				{
++					_yyValue = m_this.parseUndefined ();
++				}
++				case 45: break;
++				case 21:	// list : OPEN_BRACKET node
++				{
++					_yyValue = m_this.parseStartList ((org.jboss.dmr.ModelNode)yyGetValue (2));
++				}
++				case 46: break;
++				case 22:	// list : list COMMA node
++				{
++					_yyValue = m_this.parseListItem ((org.jboss.dmr.ModelNode)yyGetValue (1), (org.jboss.dmr.ModelNode)yyGetValue (3));
++				}
++				case 47: break;
++				case 23:	// object : OPEN_BRACE STR_VAL COLON node
++				{
++					_yyValue = m_this.parseStartObject ((java.lang.String)yyGetValue (2), (org.jboss.dmr.ModelNode)yyGetValue (4));
++				}
++				case 48: break;
++				case 24:	// object : object COMMA STR_VAL COLON node
++				{
++					_yyValue = m_this.parseObjectItem ((org.jboss.dmr.ModelNode)yyGetValue (1), (java.lang.String)yyGetValue (3), (org.jboss.dmr.ModelNode)yyGetValue (5));
++				}
++				case 49: break;
++				default:
++					throw new IOException ("Internal error in JSONParser parser.");
++			}
++
++			YYParserState cc_reduced = new YYParserState (-cc_ruleState, _yyValue, cc_toState);
++			_yyValue = null;
++			cc_stateStack.setSize (_yyArgStart + 1);
++			cc_stateStack.add (cc_reduced);
++		}
++	}
++
++	/**
++	 * This function is used by the error handling grammars to check the immediate
++	 * lookahead token on the stack.
++	 *
++	 * @return	the top of lookahead stack.
++	 */
++	protected YYParserState yyPeekLookahead ()
++	{
++		return (YYParserState)_yyLookaheadStack.getLast ();
++	}
++
++	/**
++	 * This function is used by the error handling grammars to pop an unwantted
++	 * token from the lookahead stack.
++	 */
++	protected void yyPopLookahead ()
++	{
++		_yyLookaheadStack.removeLast ();
++	}
++
++	/**
++	 * Clear the error flag.  If this flag is present and the parser again sees
++	 * another error transition, it would immediately calls yyParseError, which
++	 * would by default exit the parser.
++	 * <p>
++	 * This function is used in error recovery.
++	 */
++	protected void yyClearError ()
++	{
++		_yyInError = false;
++	}
++
++	/**
++	 * This function reports error and return true if critical error occurred, or
++	 * false if the error has been successfully recovered.  IOException is an optional
++	 * choice of reporting error.
++	 *
++	 * @param	terminal
++	 *			the terminal that caused the error.
++	 * @return	true if irrecoverable error occurred.  Or simply throw an IOException.
++	 *			false if the parsing can be continued to check for specific
++	 *			error tokens.
++	 * @throws	IOException
++	 *			in case of error.
++	 */
++	protected boolean yyParseError (int terminal) throws IOException
++	{
++		return false;
++	}
++
++	/**
++	 * Gets the object value associated with the symbol at the argument's position.
++	 *
++	 * @param	arg
++	 *			the symbol position starting from 1.
++	 * @return	the object value associated with symbol.
++	 */
++	protected Object yyGetValue (int arg)
++	{
++		return ((YYParserState)_yyStateStack.get (_yyArgStart + arg)).value;
++	}
++
++	/**
++	 * Set the object value for the current non-terminal being reduced.
++	 *
++	 * @param	value
++	 * 			the object value for the current non-terminal.
++	 */
++	protected void yySetValue (Object value)
++	{
++		_yyValue = value;
++	}
++
++
++
++
++	private final org.jboss.dmr.JSONParserImpl m_this = (org.jboss.dmr.JSONParserImpl)this;
++
++	/**
++	 * This function is used to change the initial state for the lexer.
++	 *
++	 * @param	state
++	 *			the name of the state
++	 */
++	protected void begin (String state)
++	{
++		if ("INITIAL".equals (state))
++		{
++			begin (INITIAL);
++			return;
++		}
++		throw new IllegalArgumentException ("Unknown lexer state: " + state);
++	}
++
++	/**
++	 * Push the current state onto lexer state onto stack and
++	 * begin the new state specified by the user.
++	 *
++	 * @param	state
++	 *			the new state.
++	 */
++	protected void yyPushLexerState (String state)
++	{
++		if ("INITIAL".equals (state))
++		{
++			yyPushLexerState (INITIAL);
++			return;
++		}
++		throw new IllegalArgumentException ("Unknown lexer state: " + state);
++	}
++
++	/**
++	 * Check if there are more inputs.  This function is called when EOF is
++	 * encountered.
++	 *
++	 * @return	true to indicate no more inputs.
++	 * @throws	IOException
++	 * 			in case of an IO error
++	 */
++	protected boolean yyWrap () throws IOException
++	{
++		return true;
++	}
++
++
++/*
++ * lexer properties:
++ * unicode = false
++ * bol = false
++ * backup = true
++ * cases = 26
++ * table = compressed
++ * ecs = 37
++ * states = 72
++ * max symbol value = 256
++ *
++ * memory usage:
++ * full table = 18504
++ * ecs table = 2921
++ * next = 143
++ * check = 143
++ * default = 75
++ * meta = 37
++ * compressed table = 655
++ *
++ * parser properties:
++ * symbols = 25
++ * max terminal = 276
++ * used terminals = 20
++ * non-terminals = 5
++ * rules = 24
++ * shift/reduce conflicts = 0
++ * reduct/reduce conflicts = 0
++ *
++ * memory usage:
++ * ecs table = 1152
++ * compressed table = 743
++ */
++}
+diff --git a/src/main/java/org/jboss/dmr/Parser.java b/src/main/java/org/jboss/dmr/Parser.java
+new file mode 100644
+index 0000000..9d7dbf4
+--- /dev/null
++++ b/src/main/java/org/jboss/dmr/Parser.java
+@@ -0,0 +1,1113 @@
++/*
++ * JBoss, Home of Professional Open Source.
++ * Copyright 2011, Red Hat, Inc., and individual contributors
++ * as indicated by the @author tags. See the copyright.txt file in the
++ * distribution for a full listing of individual contributors.
++ *
++ * This is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License as
++ * published by the Free Software Foundation; either version 2.1 of
++ * the License, or (at your option) any later version.
++ *
++ * This software is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public
++ * License along with this software; if not, write to the Free
++ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
++ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
++ */
++package org.jboss.dmr;
++
++import java.io.IOException;
++import java.io.InputStream;
++
++import java.util.LinkedList;
++import java.util.Vector;
++import java.util.Stack;
++
++/**
++ * @author <a href="mailto:david.lloyd@redhat.com">David M. Lloyd</a>
++ */
++public abstract class Parser
++{
++	protected final static int OPEN_BRACE = 256;
++	protected final static int CLOSE_BRACE = 257;
++	protected final static int OPEN_BRACKET = 258;
++	protected final static int CLOSE_BRACKET = 259;
++	protected final static int OPEN_PAREN = 260;
++	protected final static int CLOSE_PAREN = 261;
++	protected final static int ARROW = 262;
++	protected final static int COMMA = 263;
++	protected final static int BIG = 264;
++	protected final static int BYTES = 265;
++	protected final static int INTEGER = 266;
++	protected final static int DECIMAL = 267;
++	protected final static int EXPRESSION = 268;
++	protected final static int UNDEFINED = 269;
++	protected final static int TRUE = 270;
++	protected final static int FALSE = 271;
++	protected final static int INT_VAL = 272;
++	protected final static int INT_HEX_VAL = 273;
++	protected final static int LONG_VAL = 274;
++	protected final static int LONG_HEX_VAL = 275;
++	protected final static int DOUBLE_SPECIAL_VAL = 276;
++	protected final static int DEC_VAL = 277;
++	protected final static int STR_VAL = 278;
++	protected final static int TYPE_VAL = 279;
++
++	protected final static int INITIAL = 0;
++
++	// an internal class for lazy initiation
++	private final static class cc_lexer
++	{
++		private static char[] accept = ("\000\032\031\032\005\006\007\032\023\023\032\032\032\032\032\032\032\032\032\032\032\032\003\004\032\032\032\032\032\032\032\001\002\033\000\030\000\000\000\000\021\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\026\024\000\000\000\000\000\027\000\000\000\025\000\000\000\000\000\013\000\000\000\000\000\000\000\000\022\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\000\000\026\000\000\000\000\000\000\000\000\000\000\014\000\000\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\000\016\000\000\000\000\000\000\000\000\000\000\000\020\000\000\017").toCharArray ();
++		private static char[] ecs = ("\000\000\000\000\000\000\000\000\000\001\002\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\003\000\000\000\000\000\004\005\000\000\006\007\010\000\011\012\012\012\012\012\012\012\012\012\000\000\000\013\014\000\000\015\016\017\020\021\022\023\000\024\025\000\026\027\030\031\032\000\033\034\035\036\000\000\037\040\000\041\042\043\000\044\000\045\046\047\050\051\052\053\000\054\000\000\055\056\057\060\061\000\062\063\064\065\000\000\066\067\000\070\000\071\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\072").toCharArray ();
++		private static char[] base = ("\116\000\000\000\000\000\000\003\000\001\002\000\003\000\000\001\000\001\003\006\006\017\000\000\002\001\002\003\013\011\015\000\000\000\000\000\002\016\000\065\000\043\000\030\047\044\044\051\047\033\052\057\161\165\162\161\163\176\144\134\152\141\146\140\140\156\000\u0081\164\u0083\u0089\u008d\u0081\000\161\000\u008b\000\u008e\u0086\u008d\u0091\u0092\000\173\171\164\164\177\u0080\u0081\011\000\015\u009a\u0090\u0097\u009d\u0080\u00a1\u00a0\u009a\u00a1\u0081\u0087\u008d\u008e\u008d\000\u008f\000\000\u00a9\u00a3\u00af\000\u00a1\u0092\000\u00a4\000\u00ac\000\u009c\u008f\000\u009a\u0098\u00b6\u00a9\u00af\u00ac\u0095\u00ad\u00b3\u009f\u009a\u009c\u00a0\u00bc\u00c0\u00be\u009c\u00b4\u00c4\000\u00aa\000\u00ae\u00c1\u00c6\u00c1\u00cb\u00ac\u00b5\u00d1\u00ce\000\u00b1\000\u00cb\u00c7\000\000\u00e3").toCharArray ();
++		private static char[] next = ("\042\002\002\043\000\042\000\000\047\011\011\000\010\011\052\065\156\133\157\157\053\062\050\045\060\054\063\046\056\160\066\057\055\161\044\067\042\064\070\071\076\133\074\104\103\103\072\061\103\103\103\103\103\103\051\000\075\073\077\100\101\061\102\102\105\106\107\110\111\112\113\114\103\103\103\103\103\103\001\002\002\003\004\005\006\007\001\010\011\012\001\001\013\001\014\015\001\001\016\001\017\001\020\021\022\001\023\024\025\001\001\026\001\027\001\001\030\001\031\032\033\001\034\001\001\001\001\001\001\001\035\036\001\001\037\040\041\115\116\117\120\121\122\123\124\125\126\127\130\131\132\134\135\136\137\140\141\142\111\143\144\145\111\146\147\150\151\152\153\154\155\162\111\163\164\165\166\167\170\171\172\173\174\175\176\177\u0080\u0081\u0082\u0083\u0084\u0085\u0086\u0087\u0088\u0089\u008a\u008b\u008c\111\u008d\u008e\u008f\u0090\u0091\u0092\u0093\u0094\u0095\u0096\u0097\115\111\u0098\u0099\u009a\u009b\u009c\u009d\111\u009e\u009f\u00a0\u00a1\u00a2\111\111\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000").toCharArray ();
++		private static char[] check = ("\u00a3\002\002\003\044\044\u00a4\156\010\010\010\u00a4\007\007\012\021\133\102\133\133\013\017\010\007\016\013\017\007\014\135\022\015\013\135\003\023\044\020\024\025\033\102\031\053\051\051\030\016\051\051\051\051\051\051\010\011\032\030\034\035\036\045\047\047\054\055\056\057\060\061\062\063\051\051\051\051\051\051\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\064\065\066\067\070\071\072\073\074\075\076\077\100\101\103\104\105\106\107\110\112\114\116\117\120\121\122\124\125\126\127\130\131\132\136\137\140\141\142\143\144\145\146\147\150\151\152\153\155\160\161\162\164\165\167\171\173\174\176\177\u0080\u0081\u0082\u0083\u0084\u0085\u0086\u0087\u0088\u0089\u008a\u008b\u008c\u008d\u008e\u008f\u0090\u0092\u0094\u0095\u0096\u0097\u0098\u0099\u009a\u009b\u009c\u009e\u00a0\u00a1\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4\u00a4").toCharArray ();
++		private static char[] defaults = ("\u00a4\u00a4\001\u00a3\u00a4\u00a4\u00a4\001\001\010\001\001\001\001\001\001\001\001\001\001\001\001\u00a4\u00a4\001\001\001\001\001\001\001\u00a4\u00a4\u00a4\003\u00a4\003\001\020\001\u00a4\001\u00a4\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\047\051\001\001\001\001\001\u00a4\001\060\001\u00a4\001\001\001\001\001\u00a4\001\001\001\001\001\001\001\001\u00a4\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\u00a4\001\133\156\001\001\001\121\001\001\060\001\114\001\u00a4\001\001\u00a4\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\u00a4\001\u00a4\001\001\001\001\001\001\001\001\001\u0082\001\u00a4\001\001\u00a4\u00a4\u00a4").toCharArray ();
++		private static char[] meta = ("\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001").toCharArray ();
++	}
++
++	// an internal class for lazy initiation
++	private final static class cc_parser
++	{
++		private static char[] rule = ("\000\001\001\003\003\003\001\001\002\003\003\001\002\001\001\001\001\002\002\003\002\002\003\005\001\001\001\003\003\003\003\002\003\004\005").toCharArray ();
++		private static char[] ecs = ("\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\000\026\027\030").toCharArray ();
++		private static char[] base = ("\031\060\017\001\003\000\007\u00d4\111\112\124\125\137\140\152\153\165\012\000\005\u00d5\010\166\032\u0080\004\060\u00ca\017\000\u0081\u008b\003\u008c\067\u0096\002\000\000\u0097\u00a1\u00a2\u00ac\035\064\u00ad\u00b4\u00b5\u00bc\060\u00c4\103\u00b7\u00d8\000\u00cc\u00bf\u00e2\u00f0\u00fc\u00f5\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00f6\u00fc\u00fc\u00f7\u00f8\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00fc\u00f9\u00fc\u00fc\u00fc").toCharArray ();
++		private static char[] next = ("\ufffe\000\035\052\000\062\055\000\037\uffe1\uffff\043\000\uffe1\040\033\034\044\053\054\030\056\057\000\032\063\000\001\000\002\036\003\uffe5\050\045\004\005\051\uffe5\006\007\010\011\012\013\014\015\016\017\020\000\026\000\uffe0\000\uffe4\046\uffe0\000\000\060\uffe4\000\000\000\000\000\000\000\000\000\027\000\ufffa\ufff9\066\ufffa\ufff9\ufffa\ufff9\ufffa\ufff9\ufffa\ufff9\ufff3\ufff2\000\ufff3\ufff2\ufff3\ufff2\ufff3\ufff2\ufff3\ufff2\ufff1\ufff0\000\ufff1\ufff0\ufff1\ufff0\ufff1\ufff0\ufff1\ufff0\ufff5\uffe8\000\ufff5\uffe8\ufff5\uffe8\ufff5\uffe8\ufff5\uffe8\uffe7\uffec\000\uffe7\uffec\uffe7\uffec\uffe7\uffec\uffe7\uffec\uffef\ufff4\000\uffef\ufff4\uffef\ufff4\uffef\ufff4\uffef\ufff4\ufff8\uffee\000\ufff8\uffee\ufff8\uffee\ufff8\uffee\ufff8\uffee\uffeb\ufffb\000\uffeb\ufffb\uffeb\ufffb\uffeb\ufffb\uffeb\ufffb\ufffc\ufffd\000\ufffc\ufffd\ufffc\ufffd\ufffc\ufffd\ufffc\ufffd\ufff6\ufff7\000\ufff6\ufff7\ufff6\ufff7\ufff6\ufff7\ufff6\ufff7\uffe3\uffe2\000\uffdf\000\uffed\uffe3\uffe2\uffed\uffdf\uffed\uffde\uffed\uffea\uffed\000\uffea\uffde\uffea\000\uffea\uffe9\uffea\000\uffe9\000\uffe9\000\uffe9\uffe6\uffe9\000\uffe6\000\uffe6\041\uffe6\047\uffe6\042\067\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\021\022\023\024\025\000\031\061\064\065\070\000\000\000\000\000\000").toCharArray ();
++		private static char[] check = ("\022\071\005\035\003\044\040\023\023\031\021\025\021\031\023\004\004\025\035\035\002\040\040\005\003\044\004\000\027\000\006\000\053\034\027\000\000\034\053\000\000\000\000\000\000\000\000\000\000\000\001\001\001\061\001\054\032\061\001\001\042\054\001\001\001\001\001\001\001\001\001\001\001\010\011\063\010\011\010\011\010\011\010\011\012\013\071\012\013\012\013\012\013\012\013\014\015\071\014\015\014\015\014\015\014\015\016\017\071\016\017\016\017\016\017\016\017\020\026\071\020\026\020\026\020\026\020\026\030\036\071\030\036\030\036\030\036\030\036\037\041\071\037\041\037\041\037\041\037\041\043\047\071\043\047\043\047\043\047\043\047\050\051\071\050\051\050\051\050\051\050\051\052\055\071\052\055\052\055\052\055\052\055\056\057\071\064\071\060\056\057\060\064\060\070\060\062\060\071\062\070\062\071\062\067\062\071\067\071\067\071\067\007\067\007\007\024\007\024\007\033\007\024\065\065\033\071\071\071\071\071\071\071\071\071\071\071\071\071\071\071\072\072\072\072\072\074\074\134\137\140\160\163\163\163\163\163\163").toCharArray ();
++		private static char[] defaults = ("\071\000\000\001\003\003\003\005\007\007\007\007\007\007\007\007\007\005\021\005\023\023\007\005\007\024\027\003\033\033\007\007\033\007\000\007\001\000\000\007\007\007\007\023\023\007\023\023\007\024\007\027\023\027\000\007\023\071").toCharArray ();
++		private static char[] gotoDefault = ("\163\163\072\163\163\163\163\163\163\163\163\163\163\163\163\163\163\163\163\163\163\163\163\163\163\163\163\163\163\163\163\163\163\163\074\163\163\074\074\163\163\163\163\163\163\163\163\163\163\163\163\163\163\163\074\163\163\163").toCharArray ();
++		private static char[] lhs = ("\000\031\032\033\033\033\033\033\033\033\033\033\033\033\033\033\033\033\033\033\033\033\033\033\033\033\033\034\034\034\034\035\035\036\036").toCharArray ();
++	}
++
++	private final static class YYParserState	// internal tracking tool
++	{
++		int token;			// the current token type
++		Object value;		// the current value associated with token
++		int state;			// the current scan state
++
++		YYParserState ()	// EOF token construction
++		{
++			this (0, null, 0);
++		}
++		YYParserState (int token)
++		{
++			this (token, null, 0);
++		}
++		YYParserState (int token, Object value)
++		{
++			this (token, value, 0);
++		}
++		YYParserState (int token, Object value, int state)
++		{
++			this.token = token;
++			this.value = value;
++			this.state = state;
++		}
++	}
++
++	// lookahead stack for the parser
++	private final LinkedList _yyLookaheadStack = new LinkedList ();
++	// state stack for the parser
++	private final Vector _yyStateStack = new Vector (512, 512);
++	// flag that indicates error
++	private boolean _yyInError;
++	// internal track of the argument start
++	private int _yyArgStart;
++	// for passing value from lexer to parser
++	private Object _yyValue;
++
++	private InputStream _yyIs = System.in;
++	private byte[] _yyBuffer;
++	private int _yyBufferSize = 4096;
++	private int _yyMatchStart;
++	private int _yyBufferEnd;
++
++	private int _yyBaseState;
++
++	private int _yyTextStart;
++	private int _yyLength;
++
++	private Stack _yyLexerStack;
++	private Stack _yyInputStack;
++
++
++	/**
++	 * Set the current input.
++	 *
++	 * @param	is
++	 *			the new input.
++	 */
++	public void setInput (InputStream is)
++	{
++		_yyIs = is;
++	}
++
++	/**
++	 * Obtain the current input.
++	 *
++	 * @return	the current input
++	 */
++	public InputStream getInput ()
++	{
++		return _yyIs;
++	}
++
++	/**
++	 * Switch the current input to the new input.  The old input and already
++	 * buffered characters are pushed onto the stack.
++	 *
++	 * @param	is
++	 * 			the new input
++	 */
++	public void yyPushInput (InputStream is)
++	{
++		int len = _yyBufferEnd - _yyMatchStart;
++		byte[] leftOver = new byte[len];
++		System.arraycopy (_yyBuffer, _yyMatchStart, leftOver, 0, len);
++
++		Object[] states = new Object[4];
++		states[0] = _yyIs;
++		states[1] = leftOver;
++
++		if (_yyInputStack == null)
++			_yyInputStack = new Stack ();
++		_yyInputStack.push (states);
++
++		_yyIs = is;
++		_yyMatchStart = 0;
++		_yyBufferEnd = 0;
++	}
++
++	/**
++	 * Switch the current input to the old input on stack.  The currently
++	 * buffered characters are inserted infront of the old buffered characters.
++	 */
++	public void yyPopInput ()
++	{
++		Object[] states = (Object[])_yyInputStack.pop ();
++		_yyIs = (InputStream)states[0];
++		byte[] leftOver = (byte[])states[1];
++
++		int curLen = _yyBufferEnd - _yyMatchStart;
++
++		if ((leftOver.length + curLen) > _yyBuffer.length)
++		{
++			byte[] newBuffer = new byte[leftOver.length + curLen];
++			System.arraycopy (_yyBuffer, _yyMatchStart, newBuffer, 0, curLen);
++			System.arraycopy (leftOver, 0, newBuffer, curLen, leftOver.length);
++			_yyBuffer = newBuffer;
++			_yyMatchStart = 0;
++			_yyBufferEnd = leftOver.length + curLen;
++		}
++		else
++		{
++			int start = _yyMatchStart;
++			int end = _yyBufferEnd;
++			byte[] buffer = _yyBuffer;
++
++			for (int i = 0; start < end; ++i, ++start)
++				buffer[i] = buffer[start];
++			System.arraycopy (leftOver, 0, buffer, curLen, leftOver.length);
++			_yyMatchStart = 0;
++			_yyBufferEnd = leftOver.length + curLen;
++		}
++	}
++
++	/**
++	 * Obtain the number of input objects on the stack.
++	 *
++	 * @return	the number of input objects on the stack.
++	 */
++	public int yyInputStackSize ()
++	{
++		return _yyInputStack == null ? 0 : _yyInputStack.size ();
++	}
++
++
++	/**
++	 * Get the current token text.
++	 * <p>
++	 * Avoid calling this function unless it is absolutely necessary since it creates
++	 * a copy of the token string.  The string length can be found by reading _yyLength
++	 * or calling yyLength () function.
++	 *
++	 * @return	the current text token.
++	 */
++	public String yyText ()
++	{
++		if (_yyMatchStart == _yyTextStart)		// this is the case when we have EOF
++			return null;
++		return new String (_yyBuffer, _yyTextStart, _yyMatchStart - _yyTextStart);
++	}
++
++	/**
++	 * Get the current text token's length.  Actions specified in the CookCC file
++	 * can directly access the variable _yyLength.
++	 *
++	 * @return	the string token length
++	 */
++	public int yyLength ()
++	{
++		return _yyLength;
++	}
++
++	/**
++	 * Print the current string token to the standard output.
++	 */
++	public void echo ()
++	{
++		System.out.print (yyText ());
++	}
++
++	/**
++	 * Put all but n characters back to the input stream.  Be aware that calling
++	 * yyLess (0) is allowed, but be sure to change the state some how to avoid
++	 * an endless loop.
++	 *
++	 * @param	n
++	 * 			The number of characters.
++	 */
++	protected void yyLess (int n)
++	{
++		if (n < 0)
++			throw new IllegalArgumentException ("yyLess function requires a non-zero value.");
++		if (n > (_yyMatchStart - _yyTextStart))
++			throw new IndexOutOfBoundsException ("yyLess function called with a too large index value " + n + ".");
++		_yyMatchStart = _yyTextStart + n;
++	}
++
++	/**
++	 * Set the lexer's current state.
++	 *
++	 * @param	baseState
++	 *			the base state index
++	 */
++	protected void begin (int baseState)
++	{
++		_yyBaseState = baseState;
++	}
++
++	/**
++	 * Push the current state onto lexer state onto stack and
++	 * begin the new state specified by the user.
++	 *
++	 * @param	newState
++	 *			the new state.
++	 */
++	protected void yyPushLexerState (int newState)
++	{
++		if (_yyLexerStack == null)
++			_yyLexerStack = new Stack ();
++		_yyLexerStack.push (new Integer (_yyBaseState));
++		begin (newState);
++	}
++
++	/**
++	 * Restore the previous lexer state.
++	 */
++	protected void yyPopLexerState ()
++	{
++		begin (((Integer)_yyLexerStack.pop ()).intValue ());
++	}
++
++
++	// read more data from the input
++	protected boolean yyRefreshBuffer () throws IOException
++	{
++		if (_yyBuffer == null)
++			_yyBuffer = new byte[_yyBufferSize];
++		if (_yyMatchStart > 0)
++		{
++			if (_yyBufferEnd > _yyMatchStart)
++			{
++				System.arraycopy (_yyBuffer, _yyMatchStart, _yyBuffer, 0, _yyBufferEnd - _yyMatchStart);
++				_yyBufferEnd -= _yyMatchStart;
++				_yyMatchStart = 0;
++			}
++			else
++			{
++				_yyMatchStart = 0;
++				_yyBufferEnd = 0;
++			}
++		}
++		else if (_yyBufferEnd == _yyBuffer.length)
++		{
++			byte[] newBuffer = new byte[_yyBuffer.length + _yyBuffer.length / 2];
++			System.arraycopy (_yyBuffer, 0, newBuffer, 0, _yyBufferEnd);
++			_yyBuffer = newBuffer;
++		}
++
++		int readSize = _yyIs.read (_yyBuffer, _yyBufferEnd, _yyBuffer.length - _yyBufferEnd);
++		if (readSize > 0)
++			_yyBufferEnd += readSize;
++		else if (readSize < 0 && !yyWrap ())		// since we are at EOF, call yyWrap ().  If the return value of yyWrap is false, refresh buffer again
++			return yyRefreshBuffer ();
++		return readSize >= 0;
++	}
++
++	/**
++	 * Reset the internal buffer.
++	 */
++	public void yyResetBuffer ()
++	{
++		_yyMatchStart = 0;
++		_yyBufferEnd = 0;
++	}
++
++	/**
++	 * Set the internal buffer size.  This action can only be performed
++	 * when the buffer is empty.  Having a large buffer is useful to read
++	 * a whole file in to increase the performance sometimes.
++	 *
++	 * @param	bufferSize
++	 *			the new buffer size.
++	 */
++	public void setBufferSize (int bufferSize)
++	{
++		if (_yyBufferEnd > _yyMatchStart)
++			throw new IllegalArgumentException ("Cannot change lexer buffer size at this moment.");
++		_yyBufferSize = bufferSize;
++		_yyMatchStart = 0;
++		_yyBufferEnd = 0;
++		if (_yyBuffer != null && bufferSize != _yyBuffer.length)
++			_yyBuffer = new byte[bufferSize];
++	}
++
++	/**
++	 * Call this function to start the scanning of the input.
++	 *
++	 * @return	a token or status value.
++	 * @throws	IOException
++	 *			in case of I/O error.
++	 */
++	protected int yyLex () throws IOException
++	{
++
++		char[] cc_ecs = cc_lexer.ecs;
++		char[] cc_next = cc_lexer.next;
++		char[] cc_check = cc_lexer.check;
++		char[] cc_base = cc_lexer.base;
++		char[] cc_default = cc_lexer.defaults;
++		char[] cc_meta = cc_lexer.meta;
++		char[] cc_accept = cc_lexer.accept;
++
++		byte[] buffer = _yyBuffer;
++
++		while (true)
++		{
++			// initiate variables necessary for lookup
++			int cc_matchedState = _yyBaseState;
++
++			int matchedLength = 0;
++
++			int internalBufferEnd = _yyBufferEnd;
++			int lookahead = _yyMatchStart;
++
++			int cc_backupMatchedState = cc_matchedState;
++			int cc_backupMatchedLength = 0;
++
++			// the DFA lookup
++			while (true)
++			{
++				// check buffer status
++				if (lookahead < internalBufferEnd)
++				{
++					// now okay to process the character
++					int cc_toState;
++					int symbol = cc_ecs[buffer[lookahead] & 0xff];
++					cc_toState = cc_matchedState;
++					while (cc_check[symbol + cc_base[cc_toState]] != cc_toState)
++					{
++						cc_toState = cc_default[cc_toState];
++						if (cc_toState >= 163)
++							symbol = cc_meta[symbol];
++					}
++					cc_toState = cc_next[symbol + cc_base[cc_toState]];
++
++					if (cc_toState == 0)
++					{
++						cc_matchedState = cc_backupMatchedState;
++						matchedLength = cc_backupMatchedLength;
++						break;
++					}
++
++					cc_matchedState = cc_toState;
++					++lookahead;
++					++matchedLength;
++
++					if (cc_accept[cc_matchedState] > 0)
++					{
++						cc_backupMatchedState = cc_toState;
++						cc_backupMatchedLength = matchedLength;
++					}
++				}
++				else
++				{
++					int lookPos = lookahead - _yyMatchStart;
++					boolean refresh = yyRefreshBuffer ();
++					buffer = _yyBuffer;
++					internalBufferEnd = _yyBufferEnd;
++					lookahead = _yyMatchStart + lookPos;
++					if (! refresh)
++					{
++						// <<EOF>>
++						int cc_toState;
++						int symbol = cc_ecs[256];
++						cc_toState = cc_matchedState;
++						while (cc_check[symbol + cc_base[cc_toState]] != cc_toState)
++						{
++							cc_toState = cc_default[cc_toState];
++							if (cc_toState >= 163)
++								symbol = cc_meta[symbol];
++						}
++						cc_toState = cc_next[symbol + cc_base[cc_toState]];
++
++						if (cc_toState != 0)
++							cc_matchedState = cc_toState;
++						else
++						{
++							cc_matchedState = cc_backupMatchedState;
++							matchedLength = cc_backupMatchedLength;
++						}
++						break;
++					}
++				}
++			}
++
++			_yyTextStart = _yyMatchStart;
++			_yyMatchStart += matchedLength;
++			_yyLength = matchedLength;
++
++
++			switch (cc_accept[cc_matchedState])
++			{
++				case 1:	// \{
++				{
++					_yyValue = m_this.parseToken (); return OPEN_BRACE;
++				}
++				case 31: break;
++				case 2:	// \}
++				{
++					_yyValue = m_this.parseToken (); return CLOSE_BRACE;
++				}
++				case 32: break;
++				case 3:	// \[
++				{
++					_yyValue = m_this.parseToken (); return OPEN_BRACKET;
++				}
++				case 33: break;
++				case 4:	// \]
++				{
++					_yyValue = m_this.parseToken (); return CLOSE_BRACKET;
++				}
++				case 34: break;
++				case 5:	// \(
++				{
++					_yyValue = m_this.parseToken (); return OPEN_PAREN;
++				}
++				case 35: break;
++				case 6:	// \)
++				{
++					_yyValue = m_this.parseToken (); return CLOSE_PAREN;
++				}
++				case 36: break;
++				case 7:	// ,
++				{
++					_yyValue = m_this.parseToken (); return COMMA;
++				}
++				case 37: break;
++				case 8:	// =>
++				{
++					_yyValue = m_this.parseToken (); return ARROW;
++				}
++				case 38: break;
++				case 9:	// true
++				{
++					_yyValue = m_this.parseToken (); return TRUE;
++				}
++				case 39: break;
++				case 10:	// false
++				{
++					_yyValue = m_this.parseToken (); return FALSE;
++				}
++				case 40: break;
++				case 11:	// big
++				{
++					_yyValue = m_this.parseToken (); return BIG;
++				}
++				case 41: break;
++				case 12:	// bytes
++				{
++					_yyValue = m_this.parseToken (); return BYTES;
++				}
++				case 42: break;
++				case 13:	// decimal
++				{
++					_yyValue = m_this.parseToken (); return DECIMAL;
++				}
++				case 43: break;
++				case 14:	// integer
++				{
++					_yyValue = m_this.parseToken (); return INTEGER;
++				}
++				case 44: break;
++				case 15:	// expression
++				{
++					_yyValue = m_this.parseToken (); return EXPRESSION;
++				}
++				case 45: break;
++				case 16:	// undefined
++				{
++					_yyValue = m_this.parseToken (); return UNDEFINED;
++				}
++				case 46: break;
++				case 17:	// [+-]?[0-9]+L
++				{
++					_yyValue = m_this.parsePlainValue (); return LONG_VAL;
++				}
++				case 47: break;
++				case 18:	// [+-]?0x[0-9a-fA-F]+L
++				{
++					_yyValue = m_this.parsePlainValue (); return LONG_HEX_VAL;
++				}
++				case 48: break;
++				case 19:	// [+-]?[0-9]+
++				{
++					_yyValue = m_this.parsePlainValue (); return INT_VAL;
++				}
++				case 49: break;
++				case 20:	// [+-]?0x[0-9a-fA-F]+
++				{
++					_yyValue = m_this.parsePlainValue (); return INT_HEX_VAL;
++				}
++				case 50: break;
++				case 21:	// [+-]?(NaN|Infinity)
++				{
++					_yyValue = m_this.parsePlainValue (); return DOUBLE_SPECIAL_VAL;
++				}
++				case 51: break;
++				case 22:	// [+-]?([0-9]+\.[0-9]+([eE][+-]?[0-9]+)?)
++				{
++					_yyValue = m_this.parsePlainValue (); return DEC_VAL;
++				}
++				case 52: break;
++				case 23:	// BIG_DECIMAL|BIG_INTEGER|BOOLEAN|BYTES|DOUBLE|EXPRESSION|INT|LIST|LONG|OBJECT|PROPERTY|STRING|TYPE|UNDEFINED
++				{
++					_yyValue = m_this.parsePlainValue (); return TYPE_VAL;
++				}
++				case 53: break;
++				case 24:	// \"([^"\\]+|\\.)*\"
++				{
++					_yyValue = m_this.parseStringValue (); return STR_VAL;
++				}
++				case 54: break;
++				case 25:	// [ \t\r\n]+
++				{
++					m_this.ignored ();
++				}
++				case 55: break;
++				case 26:	// .
++				{
++					m_this.invalid ();
++				}
++				case 56: break;
++				case 27:	// <<EOF>>
++				{
++					m_this.parseEOF (); return 0;
++				}
++				case 57: break;
++				case 28:	// .|\n
++				{
++					echo ();			// default character action
++				}
++				case 58: break;
++				case 29:	// <<EOF>>
++				{
++					return 0;			// default EOF action
++				}
++				case 59: break;
++				default:
++					throw new IOException ("Internal error in Parser lexer.");
++			}
++
++		}
++	}
++
++
++	/**
++	 * Call this function to start parsing.
++	 *
++	 * @return	0 if everything is okay, or 1 if an error occurred.
++	 * @throws	IOException
++	 *			in case of error
++	 */
++	public int yyParse () throws IOException
++	{
++		char[] cc_ecs = cc_parser.ecs;
++		char[] cc_next = cc_parser.next;
++		char[] cc_check = cc_parser.check;
++		char[] cc_base = cc_parser.base;
++		char[] cc_default = cc_parser.defaults;
++		char[] cc_gotoDefault = cc_parser.gotoDefault;
++		char[] cc_rule = cc_parser.rule;
++		char[] cc_lhs = cc_parser.lhs;
++
++		LinkedList cc_lookaheadStack = _yyLookaheadStack;
++		Vector cc_stateStack = _yyStateStack;
++
++		if (cc_stateStack.size () == 0)
++			cc_stateStack.add (new YYParserState ());
++
++		int cc_toState = 0;
++
++		for (;;)
++		{
++			YYParserState cc_lookahead;
++
++			int cc_fromState;
++			char cc_ch;
++
++			//
++			// check if there are any lookahead tokens on stack
++			// if not, then call yyLex ()
++			//
++			if (cc_lookaheadStack.size () == 0)
++			{
++				_yyValue = null;
++				int val = yyLex ();
++				cc_lookahead = new YYParserState (val, _yyValue);
++				cc_lookaheadStack.add (cc_lookahead);
++			}
++			else
++				cc_lookahead = (YYParserState)cc_lookaheadStack.getLast ();
++
++			cc_ch = cc_ecs[cc_lookahead.token];
++			cc_fromState = ((YYParserState)cc_stateStack.get (cc_stateStack.size () - 1)).state;
++			int cc_symbol = cc_ch;
++			cc_toState = cc_fromState;
++			while (cc_check[cc_symbol + cc_base[cc_toState]] != cc_toState)
++			{
++				cc_toState = cc_default[cc_toState];
++				if (cc_toState >= 57)
++					cc_symbol = 0;
++			}
++			cc_toState = (short)cc_next[cc_symbol + cc_base[cc_toState]];
++
++
++			//
++			// check the value of toState and determine what to do
++			// with it
++			//
++			if (cc_toState > 0)
++			{
++				// shift
++				cc_lookahead.state = cc_toState;
++				cc_stateStack.add (cc_lookahead);
++				cc_lookaheadStack.removeLast ();
++				continue;
++			}
++			else if (cc_toState == 0)
++			{
++				// error
++				if (_yyInError)
++				{
++					// first check if the error is at the lookahead
++					if (cc_ch == 1)
++					{
++						// so we need to reduce the stack until a state with reduceable
++						// action is found
++						if (_yyStateStack.size () > 1)
++							_yyStateStack.setSize (_yyStateStack.size () - 1);
++						else
++							return 1;	// can't do much we exit the parser
++					}
++					else
++					{
++						// this means that we need to dump the lookahead.
++						if (cc_ch == 0)		// can't do much with EOF;
++							return 1;
++						cc_lookaheadStack.removeLast ();
++					}
++					continue;
++				}
++				else
++				{
++					if (yyParseError (cc_lookahead.token))
++						return 1;
++					_yyLookaheadStack.add (new YYParserState (1, _yyValue));
++					_yyInError = true;
++					continue;
++				}
++			}
++			_yyInError = false;
++			// now the reduce action
++			int cc_ruleState = -cc_toState;
++
++			_yyArgStart = cc_stateStack.size () - cc_rule[cc_ruleState] - 1;
++			//
++			// find the state that said need this non-terminal
++			//
++			cc_fromState = ((YYParserState)cc_stateStack.get (_yyArgStart)).state;
++
++			//
++			// find the state to goto after shifting the non-terminal
++			// onto the stack.
++			//
++			if (cc_ruleState == 1)
++				cc_toState = 0;			// reset the parser
++			else
++			{
++				cc_toState = cc_fromState + 58;
++				int cc_tmpCh = cc_lhs[cc_ruleState] - 25;
++				while (cc_check[cc_tmpCh + cc_base[cc_toState]] != cc_toState)
++					cc_toState = cc_gotoDefault[cc_toState - 58];
++				cc_toState = cc_next[cc_tmpCh + cc_base[cc_toState]];
++			}
++
++			_yyValue = null;
++
++			switch (cc_ruleState)
++			{
++				case 1:					// accept
++					return 0;
++				case 2:	// complete : node
++				{
++					return m_this.parse ((org.jboss.dmr.ModelNode)yyGetValue (1));
++				}
++				case 37: break;
++				case 3:	// node : BIG DECIMAL DEC_VAL
++				{
++					_yyValue = m_this.parseBigDecimal ((java.lang.String)yyGetValue (3));
++				}
++				case 38: break;
++				case 4:	// node : BIG DECIMAL INT_VAL
++				{
++					_yyValue = m_this.parseBigDecimal ((java.lang.String)yyGetValue (3));
++				}
++				case 39: break;
++				case 5:	// node : BIG INTEGER INT_VAL
++				{
++					_yyValue = m_this.parseBigInteger ((java.lang.String)yyGetValue (3));
++				}
++				case 40: break;
++				case 6:	// node : TRUE
++				{
++					_yyValue = m_this.parseTrue ();
++				}
++				case 41: break;
++				case 7:	// node : FALSE
++				{
++					_yyValue = m_this.parseFalse ();
++				}
++				case 42: break;
++				case 8:	// node : bytes CLOSE_BRACE
++				{
++					_yyValue = m_this.finishBytes ((java.io.ByteArrayOutputStream)yyGetValue (1));
++				}
++				case 43: break;
++				case 9:	// node : bytes COMMA CLOSE_BRACE
++				{
++					_yyValue = m_this.finishBytes ((java.io.ByteArrayOutputStream)yyGetValue (1));
++				}
++				case 44: break;
++				case 10:	// node : BYTES OPEN_BRACE CLOSE_BRACE
++				{
++					_yyValue = m_this.emptyBytes ();
++				}
++				case 45: break;
++				case 11:	// node : DEC_VAL
++				{
++					_yyValue = m_this.parseDouble ((java.lang.String)yyGetValue (1));
++				}
++				case 46: break;
++				case 12:	// node : EXPRESSION STR_VAL
++				{
++					_yyValue = m_this.parseExpression ((java.lang.String)yyGetValue (2));
++				}
++				case 47: break;
++				case 13:	// node : INT_VAL
++				{
++					_yyValue = m_this.parseInt ((java.lang.String)yyGetValue (1));
++				}
++				case 48: break;
++				case 14:	// node : INT_HEX_VAL
++				{
++					_yyValue = m_this.parseIntHex ((java.lang.String)yyGetValue (1));
++				}
++				case 49: break;
++				case 15:	// node : LONG_VAL
++				{
++					_yyValue = m_this.parseLong ((java.lang.String)yyGetValue (1));
++				}
++				case 50: break;
++				case 16:	// node : LONG_HEX_VAL
++				{
++					_yyValue = m_this.parseLongHex ((java.lang.String)yyGetValue (1));
++				}
++				case 51: break;
++				case 17:	// node : OPEN_BRACKET CLOSE_BRACKET
++				{
++					_yyValue = m_this.parseEmptyList ();
++				}
++				case 52: break;
++				case 18:	// node : list CLOSE_BRACKET
++				{
++					_yyValue = m_this.finishList ((org.jboss.dmr.ModelNode)yyGetValue (1));
++				}
++				case 53: break;
++				case 19:	// node : list COMMA CLOSE_BRACKET
++				{
++					_yyValue = m_this.finishList ((org.jboss.dmr.ModelNode)yyGetValue (1));
++				}
++				case 54: break;
++				case 20:	// node : OPEN_BRACE CLOSE_BRACE
++				{
++					_yyValue = m_this.parseEmptyObject ();
++				}
++				case 55: break;
++				case 21:	// node : object CLOSE_BRACE
++				{
++					_yyValue = m_this.finishObject ((org.jboss.dmr.ModelNode)yyGetValue (1));
++				}
++				case 56: break;
++				case 22:	// node : object COMMA CLOSE_BRACE
++				{
++					_yyValue = m_this.finishObject ((org.jboss.dmr.ModelNode)yyGetValue (1));
++				}
++				case 57: break;
++				case 23:	// node : OPEN_PAREN STR_VAL ARROW node CLOSE_PAREN
++				{
++					_yyValue = m_this.parseProperty ((java.lang.String)yyGetValue (2), (org.jboss.dmr.ModelNode)yyGetValue (4));
++				}
++				case 58: break;
++				case 24:	// node : STR_VAL
++				{
++					_yyValue = m_this.parseString ((java.lang.String)yyGetValue (1));
++				}
++				case 59: break;
++				case 25:	// node : TYPE_VAL
++				{
++					_yyValue = m_this.parseType ((java.lang.String)yyGetValue (1));
++				}
++				case 60: break;
++				case 26:	// node : UNDEFINED
++				{
++					_yyValue = m_this.parseUndefined ();
++				}
++				case 61: break;
++				case 27:	// bytes : BYTES OPEN_BRACE INT_VAL
++				{
++					_yyValue = m_this.startBytesInt ((java.lang.String)yyGetValue (3));
++				}
++				case 62: break;
++				case 28:	// bytes : BYTES OPEN_BRACE INT_HEX_VAL
++				{
++					_yyValue = m_this.startBytesHex ((java.lang.String)yyGetValue (3));
++				}
++				case 63: break;
++				case 29:	// bytes : bytes COMMA INT_VAL
++				{
++					_yyValue = m_this.nextByteInt ((java.io.ByteArrayOutputStream)yyGetValue (1), (java.lang.String)yyGetValue (3));
++				}
++				case 64: break;
++				case 30:	// bytes : bytes COMMA INT_HEX_VAL
++				{
++					_yyValue = m_this.nextByteHex ((java.io.ByteArrayOutputStream)yyGetValue (1), (java.lang.String)yyGetValue (3));
++				}
++				case 65: break;
++				case 31:	// list : OPEN_BRACKET node
++				{
++					_yyValue = m_this.parseStartList ((org.jboss.dmr.ModelNode)yyGetValue (2));
++				}
++				case 66: break;
++				case 32:	// list : list COMMA node
++				{
++					_yyValue = m_this.parseListItem ((org.jboss.dmr.ModelNode)yyGetValue (1), (org.jboss.dmr.ModelNode)yyGetValue (3));
++				}
++				case 67: break;
++				case 33:	// object : OPEN_BRACE STR_VAL ARROW node
++				{
++					_yyValue = m_this.parseStartObject ((java.lang.String)yyGetValue (2), (org.jboss.dmr.ModelNode)yyGetValue (4));
++				}
++				case 68: break;
++				case 34:	// object : object COMMA STR_VAL ARROW node
++				{
++					_yyValue = m_this.parseObjectItem ((org.jboss.dmr.ModelNode)yyGetValue (1), (java.lang.String)yyGetValue (3), (org.jboss.dmr.ModelNode)yyGetValue (5));
++				}
++				case 69: break;
++				default:
++					throw new IOException ("Internal error in Parser parser.");
++			}
++
++			YYParserState cc_reduced = new YYParserState (-cc_ruleState, _yyValue, cc_toState);
++			_yyValue = null;
++			cc_stateStack.setSize (_yyArgStart + 1);
++			cc_stateStack.add (cc_reduced);
++		}
++	}
++
++	/**
++	 * This function is used by the error handling grammars to check the immediate
++	 * lookahead token on the stack.
++	 *
++	 * @return	the top of lookahead stack.
++	 */
++	protected YYParserState yyPeekLookahead ()
++	{
++		return (YYParserState)_yyLookaheadStack.getLast ();
++	}
++
++	/**
++	 * This function is used by the error handling grammars to pop an unwantted
++	 * token from the lookahead stack.
++	 */
++	protected void yyPopLookahead ()
++	{
++		_yyLookaheadStack.removeLast ();
++	}
++
++	/**
++	 * Clear the error flag.  If this flag is present and the parser again sees
++	 * another error transition, it would immediately calls yyParseError, which
++	 * would by default exit the parser.
++	 * <p>
++	 * This function is used in error recovery.
++	 */
++	protected void yyClearError ()
++	{
++		_yyInError = false;
++	}
++
++	/**
++	 * This function reports error and return true if critical error occurred, or
++	 * false if the error has been successfully recovered.  IOException is an optional
++	 * choice of reporting error.
++	 *
++	 * @param	terminal
++	 *			the terminal that caused the error.
++	 * @return	true if irrecoverable error occurred.  Or simply throw an IOException.
++	 *			false if the parsing can be continued to check for specific
++	 *			error tokens.
++	 * @throws	IOException
++	 *			in case of error.
++	 */
++	protected boolean yyParseError (int terminal) throws IOException
++	{
++		return false;
++	}
++
++	/**
++	 * Gets the object value associated with the symbol at the argument's position.
++	 *
++	 * @param	arg
++	 *			the symbol position starting from 1.
++	 * @return	the object value associated with symbol.
++	 */
++	protected Object yyGetValue (int arg)
++	{
++		return ((YYParserState)_yyStateStack.get (_yyArgStart + arg)).value;
++	}
++
++	/**
++	 * Set the object value for the current non-terminal being reduced.
++	 *
++	 * @param	value
++	 * 			the object value for the current non-terminal.
++	 */
++	protected void yySetValue (Object value)
++	{
++		_yyValue = value;
++	}
++
++
++
++
++	private final org.jboss.dmr.ModelNodeParser m_this = (org.jboss.dmr.ModelNodeParser)this;
++
++	/**
++	 * This function is used to change the initial state for the lexer.
++	 *
++	 * @param	state
++	 *			the name of the state
++	 */
++	protected void begin (String state)
++	{
++		if ("INITIAL".equals (state))
++		{
++			begin (INITIAL);
++			return;
++		}
++		throw new IllegalArgumentException ("Unknown lexer state: " + state);
++	}
++
++	/**
++	 * Push the current state onto lexer state onto stack and
++	 * begin the new state specified by the user.
++	 *
++	 * @param	state
++	 *			the new state.
++	 */
++	protected void yyPushLexerState (String state)
++	{
++		if ("INITIAL".equals (state))
++		{
++			yyPushLexerState (INITIAL);
++			return;
++		}
++		throw new IllegalArgumentException ("Unknown lexer state: " + state);
++	}
++
++	/**
++	 * Check if there are more inputs.  This function is called when EOF is
++	 * encountered.
++	 *
++	 * @return	true to indicate no more inputs.
++	 * @throws	IOException
++	 * 			in case of an IO error
++	 */
++	protected boolean yyWrap () throws IOException
++	{
++		return true;
++	}
++
++
++/*
++ * lexer properties:
++ * unicode = false
++ * bol = false
++ * backup = true
++ * cases = 29
++ * table = compressed
++ * ecs = 59
++ * states = 163
++ * max symbol value = 256
++ *
++ * memory usage:
++ * full table = 41891
++ * ecs table = 9874
++ * next = 268
++ * check = 268
++ * default = 165
++ * meta = 59
++ * compressed table = 1017
++ *
++ * parser properties:
++ * symbols = 31
++ * max terminal = 279
++ * used terminals = 25
++ * non-terminals = 6
++ * rules = 34
++ * shift/reduce conflicts = 0
++ * reduct/reduce conflicts = 0
++ *
++ * memory usage:
++ * ecs table = 2047
++ * compressed table = 1028
++ */
++}
+-- 
+2.5.5
+
diff --git a/1.3.0.Final.tar.gz b/1.3.0.Final.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..64d375143510d51f1e4df5060efe248e3db0bf73
GIT binary patch
literal 46266
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%0Ay3_}$EsET|n)wR`$~ZP-%#o<+f8QgU
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
U|MQx<2mW|~j|&08garA20F$BB`Tzg`

literal 0
HcmV?d00001

diff --git a/jboss-dmr.spec b/jboss-dmr.spec
new file mode 100644
index 0000000..38f0eca
--- /dev/null
+++ b/jboss-dmr.spec
@@ -0,0 +1,41 @@
+%global namedreltag .Final
+%global namedversion %{version}%{?namedreltag}
+Name:                jboss-dmr
+Version:             1.3.0
+Release:             1
+Summary:             JBoss DMR
+License:             LGPLv2+
+URL:                 https://github.com/jbossas/jboss-dmr
+Source0:             https://github.com/jbossas/jboss-dmr/archive/%{namedversion}.tar.gz
+Patch0:              0001-Add-pre-generated-Java-classes.patch
+BuildArch:           noarch
+BuildRequires:       maven-local mvn(com.google.code.cookcc:cookcc) mvn(jdepend:jdepend)
+BuildRequires:       mvn(junit:junit) mvn(org.jboss.apiviz:apiviz:pom:)
+BuildRequires:       mvn(org.jboss:jboss-parent:pom:) mvn(org.jboss.logmanager:jboss-logmanager)
+%description
+This package contains the Dynamic Model Representation.
+
+%package javadoc
+Summary:             Javadoc for %{name}
+%description javadoc
+This package contains the API documentation for %{name}.
+
+%prep
+%setup -q -n %{name}-%{namedversion}
+%patch0 -p1
+%pom_remove_plugin :apt-maven-plugin
+%pom_remove_plugin :maven-antrun-plugin
+
+%build
+%mvn_build
+
+%install
+%mvn_install
+
+%files -f .mfiles
+
+%files javadoc -f .mfiles-javadoc
+
+%changelog
+* Fri Aug 14 2020 yaokai <yaokai13@huawei.com> - 1.3.0-1
+- Package init
diff --git a/jboss-dmr.yaml b/jboss-dmr.yaml
new file mode 100644
index 0000000..45f3c57
--- /dev/null
+++ b/jboss-dmr.yaml
@@ -0,0 +1,4 @@
+version_control: github
+src_repo: jbossas/jboss-dmr
+tag_pattern: "(.*?).Final"
+seperator: "."
-- 
Gitee