Parser.java

package st.gravel.support.compiler.ast;

/*
	This file is automatically generated from typed smalltalk source. Do not edit by hand.
	(C) AG5.com
*/

import java.math.BigInteger;
import st.gravel.support.jvm.NonLocalReturn;
import st.gravel.support.compiler.ast.Expression;
import st.gravel.support.compiler.ast.MethodNode;
import st.gravel.support.compiler.ast.SourceFile;
import st.gravel.support.compiler.ast.SequenceNode;
import st.gravel.support.compiler.ast.TypeNode;
import st.gravel.support.compiler.ast.ParseError;
import st.gravel.support.compiler.ast.ArrayLiteralNode;
import st.gravel.support.compiler.ast.LiteralNode;
import st.gravel.support.compiler.ast.AssignmentNode;
import st.gravel.support.compiler.ast.VariableNode;
import st.gravel.support.compiler.ast.BinaryMessageNode;
import st.gravel.support.compiler.ast.BinaryMethodNode;
import st.gravel.support.compiler.ast.VariableDeclarationNode;
import st.gravel.support.compiler.ast.PragmaNode;
import st.gravel.support.compiler.ast.UnaryMessageNode;
import st.gravel.support.compiler.ast.BlockNode;
import st.gravel.support.compiler.ast.ByteArrayLiteralNode;
import st.gravel.support.compiler.ast.CharacterLiteralNode;
import st.gravel.support.compiler.ast.SymbolLiteralNode;
import java.util.List;
import java.util.ArrayList;
import st.gravel.support.compiler.ast.KeywordMessageNode;
import st.gravel.support.compiler.ast.KeywordMethodNode;
import st.gravel.support.compiler.ast.MessageNode;
import st.gravel.support.compiler.ast.CascadeNode;
import st.gravel.support.compiler.ast.NumberLiteralNode;
import st.gravel.support.compiler.ast.TypeCast;
import st.gravel.support.compiler.ast.IntegerLiteralNode;
import st.gravel.support.compiler.ast.FloatLiteralNode;
import st.gravel.support.compiler.ast.FixedPointLiteralNode;
import st.gravel.support.compiler.ast.DoubleLiteralNode;
import st.gravel.support.compiler.ast.ReferenceLiteralNode;
import st.gravel.support.compiler.ast.Statement;
import st.gravel.support.compiler.ast.ReturnNode;
import st.gravel.support.compiler.ast.StringLiteralNode;
import st.gravel.support.compiler.ast.NilLiteralNode;
import st.gravel.support.compiler.ast.BooleanLiteralNode;
import st.gravel.support.compiler.ast.BlockTypeNode;
import st.gravel.support.compiler.ast.NamespacedTypeVariableNode;
import st.gravel.support.compiler.ast.SelfTypeNode;
import st.gravel.support.compiler.ast.InstanceTypeNode;
import st.gravel.support.compiler.ast.TypeVariableNode;
import st.gravel.support.compiler.ast.GenericTypeVariableNode;
import st.gravel.support.compiler.ast.UnaryMethodNode;
import st.gravel.support.compiler.ast.NamespacedVariableNode;
import st.gravel.support.compiler.ast.Node;

public class Parser extends Object implements Cloneable {

	public static Parser_Factory factory = new Parser_Factory();

	SourceFile _sourceFile;

	java.nio.CharBuffer _stream;

	public static class Parser_Factory extends st.gravel.support.jvm.SmalltalkFactory {

		public Parser basicNew() {
			Parser newInstance = new Parser();
			newInstance.initialize();
			return newInstance;
		}

		public Expression parseExpression_(final String _aString) {
			final Parser _parser;
			final Expression _res;
			_parser = this.source_(_aString);
			_res = _parser.parseExpression();
			st.gravel.support.jvm.ObjectExtensions.assert_(this, _parser.atEnd());
			return _res;
		}

		public MethodNode parseMethod_(final String _aString) {
			final Parser _parser;
			final MethodNode _res;
			_parser = this.source_(_aString);
			_res = _parser.parseMethod();
			st.gravel.support.jvm.ObjectExtensions.assert_(this, _parser.atEnd());
			return _res;
		}

		public MethodNode parseMethod_sourceFile_(final String _aString, final SourceFile _sourceFile) {
			final Parser _parser;
			final MethodNode _res;
			_parser = this.source_sourceFile_(_aString, _sourceFile);
			_res = _parser.parseMethod();
			st.gravel.support.jvm.ObjectExtensions.assert_(this, _parser.atEnd());
			return _res;
		}

		public SequenceNode parseSequence_(final String _aString) {
			final Parser _parser;
			final SequenceNode _res;
			_parser = this.source_(_aString);
			_res = _parser.parseSequence();
			st.gravel.support.jvm.ObjectExtensions.assert_(this, _parser.atEnd());
			return _res;
		}

		public TypeNode parseTypeNode_(final String _aString) {
			final Parser _parser;
			final TypeNode _res;
			_parser = this.source_(_aString);
			_res = _parser.parseTypeNode();
			st.gravel.support.jvm.ObjectExtensions.assert_(this, _parser.atEnd());
			return _res;
		}

		public Parser source_(final String _aString) {
			return this.stream_sourceFile_(st.gravel.support.jvm.ReadStreamFactory.on_(_aString), null);
		}

		public Parser source_sourceFile_(final String _aString, final SourceFile _sourceFile) {
			return this.stream_sourceFile_(st.gravel.support.jvm.ReadStreamFactory.on_(_aString), _sourceFile);
		}

		public Parser stream_sourceFile_(final java.nio.CharBuffer _aReadStream, final SourceFile _sourceFile) {
			return this.basicNew().initializeStream_sourceFile_(_aReadStream, _sourceFile);
		}
	}

	static public Expression _parseExpression_(Object receiver, final String _aString) {
		return factory.parseExpression_(_aString);
	}

	static public MethodNode _parseMethod_(Object receiver, final String _aString) {
		return factory.parseMethod_(_aString);
	}

	static public MethodNode _parseMethod_sourceFile_(Object receiver, final String _aString, final SourceFile _sourceFile) {
		return factory.parseMethod_sourceFile_(_aString, _sourceFile);
	}

	static public SequenceNode _parseSequence_(Object receiver, final String _aString) {
		return factory.parseSequence_(_aString);
	}

	static public TypeNode _parseTypeNode_(Object receiver, final String _aString) {
		return factory.parseTypeNode_(_aString);
	}

	static public Parser _source_(Object receiver, final String _aString) {
		return factory.source_(_aString);
	}

	static public Parser _source_sourceFile_(Object receiver, final String _aString, final SourceFile _sourceFile) {
		return factory.source_sourceFile_(_aString, _sourceFile);
	}

	static public Parser _stream_sourceFile_(Object receiver, final java.nio.CharBuffer _aReadStream, final SourceFile _sourceFile) {
		return factory.stream_sourceFile_(_aReadStream, _sourceFile);
	}

	public boolean atEnd() {
		return st.gravel.support.jvm.ReadStreamExtensions.atEnd(_stream);
	}

	public Parser copy() {
		try {
			Parser _temp1 = (Parser) this.clone();
			_temp1.postCopy();
			return _temp1;
		} catch (CloneNotSupportedException e) {
			throw new RuntimeException(e);
		}
	}

	public int eatComment() {
		int _i;
		_i = 1;
		st.gravel.support.jvm.ReadStreamExtensions.next(_stream);
		boolean _temp1 = false;
		while (!_temp1) {
			_temp1 = st.gravel.support.jvm.ReadStreamExtensions.atEnd(_stream);
			if (!_temp1) {
				final char _ch;
				_i = (_i + 1);
				_ch = st.gravel.support.jvm.ReadStreamExtensions.next(_stream);
				if (st.gravel.support.jvm.CharacterExtensions.equals_(_ch, '\"')) {
					if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '\"')) {
						_i = (_i + 1);
					} else {
						return _i;
					}
				}
			}
		}
		throw ParseError.factory.basicNew();
	}

	public int eatWhitespace() {
		int _i;
		_i = 0;
		boolean _temp1 = true;
		while (_temp1) {
			_temp1 = (!st.gravel.support.jvm.ReadStreamExtensions.atEnd(_stream)) && st.gravel.support.jvm.CharacterExtensions.isWhitespace(st.gravel.support.jvm.ReadStreamExtensions.peek(_stream));
			if (_temp1) {
				st.gravel.support.jvm.ReadStreamExtensions.next(_stream);
				_i = (_i + 1);
			}
		}
		if ((!st.gravel.support.jvm.ReadStreamExtensions.atEnd(_stream)) && st.gravel.support.jvm.CharacterExtensions.equals_(st.gravel.support.jvm.ReadStreamExtensions.peek(_stream), '\"')) {
			_i = (_i + Parser.this.eatComment());
			_i = (_i + Parser.this.eatWhitespace());
		}
		return _i;
	}

	public Parser_Factory factory() {
		return factory;
	}

	public Parser initialize() {
		return this;
	}

	public Parser initializeStream_sourceFile_(final java.nio.CharBuffer _aReadStream, final SourceFile _aSourceFile) {
		_sourceFile = _aSourceFile;
		_stream = _aReadStream;
		this.initialize();
		return this;
	}

	public boolean isBinarySelectorChar_(final Character _ch) {
		if (_ch == null) {
			return false;
		}
		return st.gravel.support.jvm.ArrayExtensions.includes_(new char[] { '~', '@', '%', '&', '*', '-', '+', '=', '|', '\\', '<', '>', ',', '?', '/' }, _ch);
	}

	public boolean isLetter_(final char _ch) {
		return (_ch >= 'A' && _ch <= 'Z') || (_ch >= 'a' && _ch <= 'z');
	}

	public boolean isUnderscore_(final char _ch) {
		return st.gravel.support.jvm.CharacterExtensions.equals_(_ch, '_');
	}

	public ArrayLiteralNode parseArray() {
		LiteralNode[] _elements;
		char _ch;
		st.gravel.support.jvm.ReadStreamExtensions.next(_stream);
		_elements = new LiteralNode[] {};
		this.eatWhitespace();
		boolean _temp1 = false;
		while (!_temp1) {
			_temp1 = st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ')');
			if (!_temp1) {
				_ch = st.gravel.support.jvm.ReadStreamExtensions.peek(_stream);
				if (st.gravel.support.jvm.CharacterExtensions.equals_(_ch, '#')) {
					_elements = st.gravel.support.jvm.ArrayExtensions.copyWith_(_elements, Parser.this.parseHashedLiteral());
				} else {
					if (st.gravel.support.jvm.CharacterExtensions.equals_(_ch, '(')) {
						_elements = st.gravel.support.jvm.ArrayExtensions.copyWith_(_elements, Parser.this.parseArray());
					} else {
						if (st.gravel.support.jvm.CharacterExtensions.equals_(_ch, '\'')) {
							_elements = st.gravel.support.jvm.ArrayExtensions.copyWith_(_elements, Parser.this.parseString());
						} else {
							if (st.gravel.support.jvm.CharacterExtensions.equals_(_ch, '$')) {
								_elements = st.gravel.support.jvm.ArrayExtensions.copyWith_(_elements, Parser.this.parseCharacter());
							} else {
								if (st.gravel.support.jvm.CharacterExtensions.equals_(_ch, '-')) {
									_elements = st.gravel.support.jvm.ArrayExtensions.copyWith_(_elements, Parser.this.parseNegativeNumber());
								} else {
									if (_ch >= '0' && _ch <= '9') {
										_elements = st.gravel.support.jvm.ArrayExtensions.copyWith_(_elements, Parser.this.parseNumber());
									} else {
										_elements = st.gravel.support.jvm.ArrayExtensions.copyWith_(_elements, Parser.this.parseSymbolNoHash());
									}
								}
							}
						}
					}
				}
				Parser.this.eatWhitespace();
			}
		}
		return ArrayLiteralNode.factory.elements_(_elements);
	}

	public Expression parseAssignmentOrExpression() {
		final Expression _rec;
		final int _start;
		_start = st.gravel.support.jvm.ReadStreamExtensions.position(_stream);
		_rec = this.parseExpression();
		this.eatWhitespace();
		if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ':')) {
			st.gravel.support.jvm.ObjectExtensions.assert_(Parser.this, st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '='));
			return ((Expression) Parser.this.setSourcePosition_node_(_start, Parser.this.parseAssignment_(_rec)));
		}
		return ((Expression) this.setSourcePosition_node_(_start, _rec));
	}

	public AssignmentNode parseAssignment_(final Expression _aNode) {
		final Expression _value;
		st.gravel.support.jvm.ObjectExtensions.assert_(this, _aNode.isAssignable());
		_value = this.parseAssignmentOrExpression();
		return AssignmentNode.factory.variable_value_(((VariableNode) _aNode), _value);
	}

	public Parser parseBang() {
		this.eatWhitespace();
		st.gravel.support.jvm.ObjectExtensions.assert_(this, st.gravel.support.jvm.CharacterExtensions.equals_(st.gravel.support.jvm.ReadStreamExtensions.next(_stream), '!'));
		this.eatWhitespace();
		return this;
	}

	public Expression parseBinaryMessageChain_receiver_(final String _aString, final Expression _rec) {
		final Expression _arg;
		final BinaryMessageNode _receiver;
		this.eatWhitespace();
		_arg = this.parseUnaryMessage();
		this.eatWhitespace();
		_receiver = BinaryMessageNode.factory.receiver_selector_argument_(_rec, _aString, _arg);
		return this.parseBinaryOrUnaryMessage_(_receiver);
	}

	public String parseBinaryMessageSelector() {
		Character _ch;
		final StringBuilder _str;
		_ch = st.gravel.support.jvm.ReadStreamExtensions.peek(_stream);
		if (!this.isBinarySelectorChar_(_ch)) {
			return null;
		}
		_str = st.gravel.support.jvm.WriteStreamFactory.on_(new String());
		boolean _temp1 = true;
		while (_temp1) {
			_str.append(st.gravel.support.jvm.ReadStreamExtensions.next(_stream));
			_ch = st.gravel.support.jvm.ReadStreamExtensions.peek(_stream);
			_temp1 = Parser.this.isBinarySelectorChar_(_ch);
		}
		return _str.toString();
	}

	public BinaryMethodNode parseBinaryMethod_(final String _aString) {
		final VariableDeclarationNode _argument;
		final SequenceNode _body;
		final TypeNode _returnType;
		final PragmaNode[][] _pragmas;
		_pragmas = new PragmaNode[1][];
		this.eatWhitespace();
		_argument = this.parseVariableDeclaration();
		_returnType = this.parseReturnType();
		_pragmas[0] = this.readPragmas();
		_body = this.parseSequenceNode_(new st.gravel.support.jvm.Block1<Object, PragmaNode[]>() {

			@Override
			public Object value_(final PragmaNode[] _extraPragmas) {
				return _pragmas[0] = st.gravel.support.jvm.ArrayExtensions.copyWithAll_(_pragmas[0], _extraPragmas);
			}
		});
		return BinaryMethodNode.factory.selector_argument_body_returnType_pragmas_protocol_(_aString, _argument, _body, _returnType, _pragmas[0], null);
	}

	public Expression parseBinaryOrUnaryMessage() {
		final Expression _receiver;
		_receiver = this.parseOperand();
		return this.parseBinaryOrUnaryMessage_(_receiver);
	}

	public Expression parseBinaryOrUnaryMessage_(final Expression _receiver) {
		String _res;
		this.eatWhitespace();
		_res = this.parseIdentifier();
		if (_res != null) {
			if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ':')) {
				st.gravel.support.jvm.ReadStreamExtensions.skip_(_stream, (-1 - _res.length()));
				return _receiver;
			} else {
				return Parser.this.parseBinaryOrUnaryMessage_(UnaryMessageNode.factory.receiver_selector_(_receiver, _res));
			}
		}
		_res = this.parseBinaryMessageSelector();
		if (_res != null) {
			return Parser.this.parseBinaryMessageChain_receiver_(_res, _receiver);
		}
		return _receiver;
	}

	public BlockNode parseBlock() {
		VariableDeclarationNode[] _arguments;
		final BlockNode _bn;
		TypeNode _returnType;
		final int _start;
		_start = st.gravel.support.jvm.ReadStreamExtensions.position(_stream);
		st.gravel.support.jvm.ReadStreamExtensions.next(_stream);
		this.eatWhitespace();
		_arguments = new VariableDeclarationNode[] {};
		if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ':')) {
			boolean _temp1 = true;
			while (_temp1) {
				Parser.this.eatWhitespace();
				_arguments = st.gravel.support.jvm.ArrayExtensions.copyWith_(_arguments, Parser.this.parseVariableDeclaration());
				Parser.this.eatWhitespace();
				_temp1 = st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ':');
			}
			_returnType = Parser.this.parseReturnType();
			Parser.this.eatWhitespace();
			if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ']')) {
				return BlockNode.factory.arguments_body_returnType_(_arguments, SequenceNode.factory.empty(), _returnType);
			}
			st.gravel.support.jvm.ObjectExtensions.assert_(Parser.this, st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '|'));
		} else {
			_returnType = Parser.this.parseReturnType();
			if (_returnType != null) {
				Parser.this.eatWhitespace();
				st.gravel.support.jvm.ObjectExtensions.assert_(Parser.this, st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '|'));
			}
		}
		_bn = BlockNode.factory.arguments_body_returnType_(_arguments, this.parseSequenceNode_(new st.gravel.support.jvm.Block1<Object, PragmaNode[]>() {

			@Override
			public Object value_(final PragmaNode[] _extraPragmas) {
				throw new RuntimeException("Extra pragmas not allowed");
			}
		}), _returnType);
		st.gravel.support.jvm.ObjectExtensions.assert_(this, st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ']'));
		return ((BlockNode) this.setSourcePosition_node_(_start, _bn));
	}

	public ByteArrayLiteralNode parseByteArray() {
		byte[] _bytes;
		st.gravel.support.jvm.ReadStreamExtensions.next(_stream);
		this.eatWhitespace();
		_bytes = new byte[] {};
		boolean _temp1 = false;
		while (!_temp1) {
			_temp1 = st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ']');
			if (!_temp1) {
				_bytes = st.gravel.support.jvm.ByteArrayExtensions.copyWith_(_bytes, st.gravel.support.jvm.IntegerExtensions.asInt(Parser.this.readInteger()));
				Parser.this.eatWhitespace();
			}
		}
		return ByteArrayLiteralNode.factory.value_(_bytes);
	}

	public CharacterLiteralNode parseCharacter() {
		st.gravel.support.jvm.ReadStreamExtensions.next(_stream);
		return CharacterLiteralNode.factory.value_(st.gravel.support.jvm.ReadStreamExtensions.next(_stream));
	}

	public Expression parseExpression() {
		final Expression _receiver;
		final int _start;
		_start = st.gravel.support.jvm.ReadStreamExtensions.position(_stream);
		this.eatWhitespace();
		_receiver = this.parseOperand();
		return ((Expression) this.setSourcePosition_node_(_start, this.parseMessageChain_(((Expression) this.setSourcePosition_node_(_start, _receiver)))));
	}

	public LiteralNode parseHashedLiteral() {
		final char _ch;
		st.gravel.support.jvm.ReadStreamExtensions.next(_stream);
		_ch = st.gravel.support.jvm.ReadStreamExtensions.peek(_stream);
		if (this.isLetter_(_ch)) {
			return Parser.this.parseSymbolNoHash_(Parser.this.parseIdentifier());
		}
		return this.parseHashedLiteralNoHash();
	}

	public LiteralNode parseHashedLiteralNoHash() {
		final Character _ch;
		_ch = st.gravel.support.jvm.ReadStreamExtensions.peek(_stream);
		if (st.gravel.support.jvm.CharacterExtensions.equals_(_ch, '(')) {
			return Parser.this.parseArray();
		}
		if (st.gravel.support.jvm.CharacterExtensions.equals_(_ch, '\'')) {
			return SymbolLiteralNode.factory.value_(st.gravel.core.Symbol.value(Parser.this.readString()));
		}
		if (st.gravel.support.jvm.CharacterExtensions.equals_(_ch, '[')) {
			return Parser.this.parseByteArray();
		}
		if (st.gravel.support.jvm.CharacterExtensions.equals_(_ch, '{')) {
			return Parser.this.parseReference();
		}
		if (this.isBinarySelectorChar_(_ch)) {
			return SymbolLiteralNode.factory.value_(st.gravel.core.Symbol.value(Parser.this.parseBinaryMessageSelector()));
		}
		return this.parseSymbolNoHash();
	}

	public String parseIdentifier() {
		Character _ch;
		final StringBuilder _wStr;
		Character _temp1 = this.peekLetter();
		_ch = _temp1 == null ? this.peekUnderscore() : _temp1;
		if (_ch == null) {
			return null;
		}
		_wStr = st.gravel.support.jvm.WriteStreamFactory.on_(new String());
		_wStr.append(_ch);
		_ch = this.peekLetterDigitOrUnderscore();
		boolean _temp2 = false;
		while (!_temp2) {
			_temp2 = _ch == null;
			if (!_temp2) {
				_wStr.append(_ch);
				_ch = Parser.this.peekLetterDigitOrUnderscore();
			}
		}
		return _wStr.toString();
	}

	public String parseKeywordIdentifier() {
		final String _res;
		_res = this.parseIdentifier();
		if (_res == null) {
			return null;
		}
		if (!st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ':')) {
			st.gravel.support.jvm.ReadStreamExtensions.skip_(_stream, (0 - _res.length()));
			return null;
		}
		if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '=')) {
			st.gravel.support.jvm.ReadStreamExtensions.skip_(_stream, (-2 - _res.length()));
			return null;
		}
		return _res + ':';
	}

	public Expression parseKeywordMessageChain_receiver_(final String _aString, final Expression _receiver) {
		String _res;
		final StringBuilder _str;
		final List<Expression> _arguments;
		_str = st.gravel.support.jvm.WriteStreamFactory.on_(new String());
		_str.append(_aString);
		_str.append(':');
		_arguments = new java.util.ArrayList();
		this.eatWhitespace();
		_arguments.add(this.parseBinaryOrUnaryMessage());
		this.eatWhitespace();
		_res = this.parseIdentifier();
		boolean _temp1 = false;
		while (!_temp1) {
			_temp1 = _res == null;
			if (!_temp1) {
				st.gravel.support.jvm.ObjectExtensions.assert_(Parser.this, st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ':'));
				_str.append(_res);
				_str.append(':');
				Parser.this.eatWhitespace();
				_arguments.add(Parser.this.parseBinaryOrUnaryMessage());
				Parser.this.eatWhitespace();
				_res = Parser.this.parseIdentifier();
			}
		}
		return KeywordMessageNode.factory.receiver_selector_arguments_(_receiver, _str.toString(), _arguments.toArray(new Expression[_arguments.size()]));
	}

	public KeywordMethodNode parseKeywordMethod_(final String _aString) {
		String _res;
		final StringBuilder _str;
		final List<VariableDeclarationNode> _arguments;
		final SequenceNode _body;
		final TypeNode _returnType;
		final PragmaNode[][] _pragmas;
		_pragmas = new PragmaNode[1][];
		_str = st.gravel.support.jvm.WriteStreamFactory.on_(new String());
		_str.append(_aString);
		_str.append(':');
		_arguments = new java.util.ArrayList();
		this.eatWhitespace();
		_arguments.add(this.parseVariableDeclaration());
		this.eatWhitespace();
		_res = this.parseKeywordIdentifier();
		boolean _temp1 = false;
		while (!_temp1) {
			_temp1 = _res == null;
			if (!_temp1) {
				_str.append(_res);
				Parser.this.eatWhitespace();
				_arguments.add(Parser.this.parseVariableDeclaration());
				Parser.this.eatWhitespace();
				_res = Parser.this.parseKeywordIdentifier();
			}
		}
		_returnType = this.parseReturnType();
		_pragmas[0] = this.readPragmas();
		_body = this.parseSequenceNode_(new st.gravel.support.jvm.Block1<Object, PragmaNode[]>() {

			@Override
			public Object value_(final PragmaNode[] _extraPragmas) {
				return _pragmas[0] = st.gravel.support.jvm.ArrayExtensions.copyWithAll_(_pragmas[0], _extraPragmas);
			}
		});
		return KeywordMethodNode.factory.selector_arguments_body_returnType_pragmas_protocol_(_str.toString(), _arguments.toArray(new VariableDeclarationNode[_arguments.size()]), _body, _returnType, _pragmas[0], null);
	}

	public Expression parseMessageChain_(final Expression _receiver) {
		final Expression _exp;
		List<MessageNode> _messages;
		_exp = this.parseNoCascadeMessageChain_(_receiver);
		this.eatWhitespace();
		if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ';')) {
			final MessageNode _baseMsg;
			_messages = new java.util.ArrayList();
			_baseMsg = ((MessageNode) _exp);
			_messages.add(_baseMsg);
			boolean _temp1 = true;
			while (_temp1) {
				final MessageNode _msg;
				_msg = ((MessageNode) Parser.this.parseNoCascadeMessageChain_(_baseMsg.receiver()));
				_messages.add(_msg);
				_temp1 = st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ';');
			}
			return CascadeNode.factory.messages_(_messages.toArray(new MessageNode[_messages.size()]));
		}
		return _exp;
	}

	public MethodNode parseMethod() {
		String _res;
		final int _start;
		_start = st.gravel.support.jvm.ReadStreamExtensions.position(_stream);
		this.eatWhitespace();
		_res = this.parseIdentifier();
		if (_res != null) {
			return ((MethodNode) Parser.this.setSourcePosition_node_(_start, st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ':') ? Parser.this.parseKeywordMethod_(_res) : Parser.this.parseUnaryMethod_(_res)));
		}
		_res = this.parseBinaryMessageSelector();
		if (_res != null) {
			return ((MethodNode) Parser.this.setSourcePosition_node_(_start, Parser.this.parseBinaryMethod_(_res)));
		}
		return null;
	}

	public NumberLiteralNode parseNegativeNumber() {
		st.gravel.support.jvm.ReadStreamExtensions.next(_stream);
		if (!st.gravel.support.jvm.CharacterExtensions.isDigit(st.gravel.support.jvm.ReadStreamExtensions.peek(_stream))) {
			st.gravel.support.jvm.ReadStreamExtensions.skip_(_stream, -1);
			return null;
		}
		return this.parseNumber().negated();
	}

	public Expression parseNestedExpression() {
		Expression _exp;
		final int _start;
		final TypeNode _typeCast;
		_start = st.gravel.support.jvm.ReadStreamExtensions.position(_stream);
		st.gravel.support.jvm.ReadStreamExtensions.next(_stream);
		this.eatWhitespace();
		_typeCast = st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '{') ? this.parseTypeExpressionAndClose() : null;
		_exp = this.parseAssignmentOrExpression();
		if (_typeCast != null) {
			_exp = TypeCast.factory.type_expression_(_typeCast, _exp);
		}
		this.eatWhitespace();
		st.gravel.support.jvm.ObjectExtensions.assert_(this, st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ')'));
		return ((Expression) this.setSourcePosition_node_(_start, _exp));
	}

	public Expression parseNoCascadeMessageChain_(final Expression _receiver) {
		String _res;
		this.eatWhitespace();
		_res = this.parseIdentifier();
		if (_res != null) {
			return st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ':') ? Parser.this.parseKeywordMessageChain_receiver_(_res, _receiver) : Parser.this.parseNoCascadeMessageChain_(UnaryMessageNode.factory.receiver_selector_(_receiver, _res));
		}
		_res = this.parseBinaryMessageSelector();
		if (_res != null) {
			return Parser.this.parseNoCascadeMessageChain_(Parser.this.parseBinaryMessageChain_receiver_(_res, _receiver));
		}
		return _receiver;
	}

	public NumberLiteralNode parseNumber() {
		final java.math.BigInteger _value;
		String _fractionString;
		_value = this.readInteger_(10);
		if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, 'r')) {
			return IntegerLiteralNode.factory.integer_(Parser.this.readInteger_(st.gravel.support.jvm.IntegerExtensions.asInt(_value)));
		}
		_fractionString = null;
		if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '.')) {
			_fractionString = Parser.this.readDigits();
			if (_fractionString.length() == 0) {
				st.gravel.support.jvm.ReadStreamExtensions.skip_(_stream, -1);
				return IntegerLiteralNode.factory.integer_(_value);
			}
		}
		if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, 'e')) {
			final int _exSign;
			final java.math.BigInteger _exponent;
			_exSign = st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '-') ? -1 : 1;
			_exponent = st.gravel.support.jvm.LargeIntegerExtensions.multiply_(Parser.this.readInteger_(10), _exSign);
			return FloatLiteralNode.factory.integer_fractionString_exponent_(_value, _fractionString, _exponent);
		} else {
			if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, 's')) {
				int _scale;
				_scale = st.gravel.support.jvm.IntegerExtensions.asInt(Parser.this.readInteger_(10));
				if (_fractionString == null) {
					_fractionString = "";
				}
				_scale = java.lang.Math.max(_scale, _fractionString.length());
				return FixedPointLiteralNode.factory.integer_fractionString_scale_(_value, _fractionString, _scale);
			} else {
				if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, 'd')) {
					final int _exSign;
					final java.math.BigInteger _exponent;
					_exSign = st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '-') ? -1 : 1;
					_exponent = st.gravel.support.jvm.LargeIntegerExtensions.multiply_(Parser.this.readInteger_(10), _exSign);
					return DoubleLiteralNode.factory.integer_fractionString_exponent_(_value, _fractionString, _exponent);
				}
			}
		}
		return _fractionString == null ? IntegerLiteralNode.factory.integer_(_value) : FloatLiteralNode.factory.integer_fractionString_exponent_(_value, _fractionString, null);
	}

	public Expression parseOperand() {
		final Character _ch;
		_ch = st.gravel.support.jvm.ReadStreamExtensions.peek(_stream);
		if (st.gravel.support.jvm.CharacterExtensions.isDigit(_ch)) {
			return Parser.this.parseNumber();
		}
		if (st.gravel.support.jvm.CharacterExtensions.equals_(_ch, '-')) {
			return Parser.this.parseNegativeNumber();
		}
		if (st.gravel.support.jvm.CharacterExtensions.equals_(_ch, '$')) {
			return Parser.this.parseCharacter();
		}
		if (st.gravel.support.jvm.CharacterExtensions.equals_(_ch, '\'')) {
			return Parser.this.parseString();
		}
		if (st.gravel.support.jvm.CharacterExtensions.equals_(_ch, '#')) {
			return Parser.this.parseHashedLiteral();
		}
		if (st.gravel.support.jvm.CharacterExtensions.equals_(_ch, '[')) {
			return Parser.this.parseBlock();
		}
		if (st.gravel.support.jvm.CharacterExtensions.equals_(_ch, '(')) {
			return Parser.this.parseNestedExpression();
		}
		return this.parseVariable();
	}

	public ReferenceLiteralNode parseReference() {
		String[] _elements;
		st.gravel.support.jvm.ReadStreamExtensions.next(_stream);
		_elements = new String[] {};
		boolean _temp1 = false;
		while (!_temp1) {
			_temp1 = st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '}');
			if (!_temp1) {
				_elements = st.gravel.support.jvm.ArrayExtensions.copyWith_(_elements, Parser.this.parseIdentifier());
				st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '.');
			}
		}
		return ReferenceLiteralNode.factory.path_(_elements);
	}

	public TypeNode parseReturnType() {
		this.eatWhitespace();
		if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '{')) {
			Parser.this.eatWhitespace();
			st.gravel.support.jvm.ObjectExtensions.assert_(Parser.this, st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '^'));
			return Parser.this.parseTypeExpressionAndClose();
		}
		return null;
	}

	public SequenceNode parseSequence() {
		return this.parseSequenceNode_(new st.gravel.support.jvm.Block1<Object, PragmaNode[]>() {

			@Override
			public Object value_(final PragmaNode[] _pragmas) {
				return Parser.this;
			}
		});
	}

	public SequenceNode parseSequenceNode_(final st.gravel.support.jvm.Block1<Object, PragmaNode[]> _extraPragmaBlock) {
		VariableDeclarationNode[] _temporaries;
		Statement[] _statements;
		Statement _statement;
		final int _start;
		final PragmaNode[] _pragmas;
		_start = st.gravel.support.jvm.ReadStreamExtensions.position(_stream);
		this.eatWhitespace();
		_temporaries = new VariableDeclarationNode[] {};
		if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '|')) {
			Parser.this.eatWhitespace();
			boolean _temp1 = false;
			while (!_temp1) {
				_temp1 = st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '|');
				if (!_temp1) {
					Parser.this.eatWhitespace();
					_temporaries = st.gravel.support.jvm.ArrayExtensions.copyWith_(_temporaries, Parser.this.parseVariableDeclaration());
					Parser.this.eatWhitespace();
				}
			}
		}
		_pragmas = this.readPragmas();
		if (_pragmas.length != 0) {
			_extraPragmaBlock.value_(_pragmas);
		}
		_statements = new Statement[] {};
		_statement = this.parseStatement();
		this.eatWhitespace();
		boolean _temp2 = false;
		while (!_temp2) {
			_temp2 = _statement == null;
			if (!_temp2) {
				_statements = st.gravel.support.jvm.ArrayExtensions.copyWith_(_statements, _statement);
				st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '.');
				_statement = Parser.this.parseStatement();
				Parser.this.eatWhitespace();
			}
		}
		return ((SequenceNode) this.setSourcePosition_node_(_start, SequenceNode.factory.temporaries_statements_(_temporaries, _statements)));
	}

	public Statement parseStatement() {
		final int _start;
		_start = st.gravel.support.jvm.ReadStreamExtensions.position(_stream);
		this.eatWhitespace();
		if (st.gravel.support.jvm.ReadStreamExtensions.atEnd(_stream)) {
			return null;
		}
		if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '^')) {
			return ((Statement) Parser.this.setSourcePosition_node_(_start, ReturnNode.factory.value_(Parser.this.parseAssignmentOrExpression())));
		}
		return ((Statement) this.setSourcePosition_node_(_start, this.parseAssignmentOrExpression()));
	}

	public StringLiteralNode parseString() {
		return StringLiteralNode.factory.value_(this.readString());
	}

	public LiteralNode parseSymbolNoHash() {
		final String _id;
		_id = this.parseIdentifier();
		if (st.gravel.support.jvm.StringExtensions.equals_(_id, "nil")) {
			return NilLiteralNode.factory.basicNew();
		}
		if (st.gravel.support.jvm.StringExtensions.equals_(_id, "true")) {
			return BooleanLiteralNode.factory.value_(true);
		}
		if (st.gravel.support.jvm.StringExtensions.equals_(_id, "false")) {
			return BooleanLiteralNode.factory.value_(false);
		}
		if (_id == null) {
			final String _bin;
			_bin = Parser.this.parseBinaryMessageSelector();
			st.gravel.support.jvm.ObjectExtensions.assert_(Parser.this, _bin != null);
			return SymbolLiteralNode.factory.value_(st.gravel.core.Symbol.value(_bin));
		}
		return this.parseSymbolNoHash_(_id);
	}

	public SymbolLiteralNode parseSymbolNoHash_(final String _start) {
		String _id;
		String _t;
		_id = _start;
		if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ':')) {
			_id = _id + ':';
			boolean _temp1 = true;
			while (_temp1) {
				_t = Parser.this.parseKeywordIdentifier();
				if (_t != null) {
					_id = _id + _t;
				}
				_temp1 = _t != null;
			}
		}
		return SymbolLiteralNode.factory.value_(st.gravel.core.Symbol.value(_id));
	}

	public TypeNode parseTypeExpressionAndClose() {
		final TypeNode _exp;
		_exp = this.parseTypeNode();
		st.gravel.support.jvm.ObjectExtensions.assert_(this, st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '}'));
		return _exp;
	}

	public BlockTypeNode parseTypeExpressionBlockAndClose() {
		TypeNode[] _args;
		TypeNode _returnType;
		_args = new TypeNode[] {};
		_returnType = null;
		boolean _temp1 = true;
		while (_temp1) {
			Parser.this.eatWhitespace();
			if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '^')) {
				_returnType = Parser.this.parseTypeNode();
			} else {
				_args = st.gravel.support.jvm.ArrayExtensions.copyWith_(_args, Parser.this.parseTypeNode());
			}
			Parser.this.eatWhitespace();
			_temp1 = st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ',');
		}
		st.gravel.support.jvm.ObjectExtensions.assert_(this, st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ']'));
		return BlockTypeNode.factory.arguments_returnType_(_args, _returnType);
	}

	public TypeNode[] parseTypeExpressionListAndClose() {
		final BlockTypeNode _block;
		_block = this.parseTypeExpressionBlockAndClose();
		st.gravel.support.jvm.ObjectExtensions.assert_(this, _block.returnType() == null);
		return _block.arguments();
	}

	public TypeNode parseTypeNode() {
		TypeNode _exp;
		_exp = this.parseTypeOperand();
		this.eatWhitespace();
		boolean _temp1 = true;
		while (_temp1) {
			_temp1 = st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '|');
			if (_temp1) {
				_exp = _exp.$pipe$(Parser.this.parseTypeOperand());
				Parser.this.eatWhitespace();
			}
		}
		return _exp;
	}

	public TypeNode parseTypeOperand() {
		final String _id;
		TypeNode _base;
		TypeNode[] _args;
		TypeNode _exp;
		this.eatWhitespace();
		_id = this.parseIdentifier();
		if (_id != null) {
			if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '.')) {
				String[] _arr;
				_arr = st.gravel.support.jvm.ArrayFactory.with_with_(_id, Parser.this.parseIdentifier());
				boolean _temp1 = true;
				while (_temp1) {
					_temp1 = st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '.');
					if (_temp1) {
						_arr = st.gravel.support.jvm.ArrayExtensions.copyWith_(_arr, Parser.this.parseIdentifier());
					}
				}
				_base = NamespacedTypeVariableNode.factory.path_(_arr);
			} else {
				if (st.gravel.support.jvm.StringExtensions.equals_(_id, "Self")) {
					_base = SelfTypeNode.factory.basicNew();
				} else {
					if (st.gravel.support.jvm.StringExtensions.equals_(_id, "Instance")) {
						_base = InstanceTypeNode.factory.basicNew();
					} else {
						_base = TypeVariableNode.factory.name_(_id);
					}
				}
			}
			Parser.this.eatWhitespace();
			if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '[')) {
				_args = Parser.this.parseTypeExpressionListAndClose();
				_exp = GenericTypeVariableNode.factory.root_arguments_(_base, _args);
			} else {
				_exp = _base;
			}
			Parser.this.eatWhitespace();
			if (st.gravel.support.jvm.CharacterExtensions.equals_(st.gravel.support.jvm.ReadStreamExtensions.peek(_stream), 'd')) {
				final String _defString;
				_defString = st.gravel.support.jvm.ReadStreamExtensions.next_(_stream, 3);
				st.gravel.support.jvm.ObjectExtensions.assert_(Parser.this, st.gravel.support.jvm.StringExtensions.equals_(_defString, "def"));
				return _exp.asDefNode();
			} else {
				return _exp;
			}
		}
		if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '[')) {
			return Parser.this.parseTypeExpressionBlockAndClose();
		}
		throw ParseError.factory.basicNew();
	}

	public Expression parseUnaryMessage() {
		final Expression _receiver;
		_receiver = this.parseOperand();
		return this.parseUnaryMessage_(_receiver);
	}

	public Expression parseUnaryMessage_(final Expression _receiver) {
		final String _res;
		this.eatWhitespace();
		_res = this.parseIdentifier();
		if (_res != null) {
			if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ':')) {
				st.gravel.support.jvm.ReadStreamExtensions.skip_(_stream, (-1 - _res.length()));
				return _receiver;
			} else {
				return Parser.this.parseUnaryMessage_(UnaryMessageNode.factory.receiver_selector_(_receiver, _res));
			}
		}
		return _receiver;
	}

	public MethodNode parseUnaryMethod_(final String _aString) {
		final SequenceNode _body;
		final TypeNode _returnType;
		final PragmaNode[][] _pragmas;
		_pragmas = new PragmaNode[1][];
		_returnType = this.parseReturnType();
		_pragmas[0] = this.readPragmas();
		_body = this.parseSequenceNode_(new st.gravel.support.jvm.Block1<Object, PragmaNode[]>() {

			@Override
			public Object value_(final PragmaNode[] _extraPragmas) {
				return _pragmas[0] = st.gravel.support.jvm.ArrayExtensions.copyWithAll_(_pragmas[0], _extraPragmas);
			}
		});
		return UnaryMethodNode.factory.selector_body_returnType_pragmas_protocol_(_aString, _body, _returnType, _pragmas[0], null);
	}

	public Expression parseVariable() {
		final String _name;
		_name = this.parseIdentifier();
		if (_name == null) {
			return null;
		}
		if (st.gravel.support.jvm.StringExtensions.equals_(_name, "nil")) {
			return NilLiteralNode.factory.basicNew();
		}
		if (st.gravel.support.jvm.StringExtensions.equals_(_name, "true")) {
			return BooleanLiteralNode.factory.value_(true);
		}
		if (st.gravel.support.jvm.StringExtensions.equals_(_name, "false")) {
			return BooleanLiteralNode.factory.value_(false);
		}
		if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '.')) {
			String[] _path;
			if ((!st.gravel.support.jvm.ReadStreamExtensions.atEnd(_stream)) && new st.gravel.support.jvm.Predicate0() {

				@Override
				public boolean value() {
					final Character _ch;
					_ch = st.gravel.support.jvm.ReadStreamExtensions.peek(_stream);
					return Parser.this.isLetter_(_ch) || Parser.this.isUnderscore_(_ch);
				}
			}.value()) {
				_path = st.gravel.support.jvm.ArrayFactory.with_(_name);
				boolean _temp1 = true;
				while (_temp1) {
					final String _identifier;
					_identifier = Parser.this.parseIdentifier();
					if (_identifier != null) {
						_path = st.gravel.support.jvm.ArrayExtensions.copyWith_(_path, _identifier);
					}
					_temp1 = st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '.');
				}
				return NamespacedVariableNode.factory.path_(_path);
			} else {
				st.gravel.support.jvm.ReadStreamExtensions.skip_(_stream, -1);
			}
		}
		return VariableNode.factory.name_(_name);
	}

	public VariableDeclarationNode parseVariableDeclaration() {
		final String _varName;
		TypeNode _type;
		int _wsWidth;
		final int _start;
		_start = st.gravel.support.jvm.ReadStreamExtensions.position(_stream);
		_varName = this.parseIdentifier();
		this.eatWhitespace();
		_type = null;
		if (st.gravel.support.jvm.CharacterExtensions.equals_(st.gravel.support.jvm.ReadStreamExtensions.peek(_stream), '{')) {
			st.gravel.support.jvm.ReadStreamExtensions.next(_stream);
			_wsWidth = Parser.this.eatWhitespace();
			if (st.gravel.support.jvm.CharacterExtensions.equals_(st.gravel.support.jvm.ReadStreamExtensions.peek(_stream), '^')) {
				st.gravel.support.jvm.ReadStreamExtensions.skip_(_stream, (-1 - _wsWidth));
			} else {
				_type = Parser.this.parseTypeExpressionAndClose();
			}
		}
		return ((VariableDeclarationNode) this.setSourcePosition_node_(_start, VariableDeclarationNode.factory.name_type_(_varName, _type)));
	}

	public Character peekDigit() {
		final Character _ch;
		_ch = st.gravel.support.jvm.ReadStreamExtensions.peek(_stream);
		if (_ch == null) {
			return null;
		}
		if (_ch >= '0' && _ch <= '9') {
			return st.gravel.support.jvm.ReadStreamExtensions.next(_stream);
		}
		return null;
	}

	public Character peekLetter() {
		final Character _ch;
		_ch = st.gravel.support.jvm.ReadStreamExtensions.peek(_stream);
		if (_ch == null) {
			return null;
		}
		if (this.isLetter_(_ch)) {
			return st.gravel.support.jvm.ReadStreamExtensions.next(_stream);
		}
		return null;
	}

	public Character peekLetterDigitOrUnderscore() {
		final Character _letter;
		_letter = this.peekLetter();
		if (_letter != null) {
			return _letter;
		}
		Character _temp1 = this.peekDigit();
		return _temp1 == null ? this.peekUnderscore() : _temp1;
	}

	public Character peekUnderscore() {
		final Character _ch;
		_ch = st.gravel.support.jvm.ReadStreamExtensions.peek(_stream);
		if (_ch == null) {
			return null;
		}
		if (this.isUnderscore_(_ch)) {
			return st.gravel.support.jvm.ReadStreamExtensions.next(_stream);
		}
		return null;
	}

	public int position() {
		return st.gravel.support.jvm.ReadStreamExtensions.position(_stream);
	}

	public Parser postCopy() {
		return this;
	}

	public String readDigits() {
		final StringBuilder _str;
		_str = st.gravel.support.jvm.WriteStreamFactory.on_(new String());
		boolean _temp1 = true;
		while (_temp1) {
			_temp1 = (!st.gravel.support.jvm.ReadStreamExtensions.atEnd(_stream)) && new st.gravel.support.jvm.Predicate0() {

				@Override
				public boolean value() {
					final int _v;
					_v = st.gravel.support.jvm.CharacterExtensions.digitValue(st.gravel.support.jvm.ReadStreamExtensions.peek(_stream));
					return (_v >= 0) && (_v <= 10);
				}
			}.value();
			if (_temp1) {
				_str.append(st.gravel.support.jvm.ReadStreamExtensions.next(_stream));
			}
		}
		return _str.toString();
	}

	public java.math.BigInteger readInteger() {
		final java.math.BigInteger _value;
		_value = this.readInteger_(10);
		if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, 'r')) {
			return Parser.this.readInteger_(st.gravel.support.jvm.IntegerExtensions.asInt(_value));
		}
		return _value;
	}

	public java.math.BigInteger readInteger_(final int _base) {
		java.math.BigInteger _value;
		_value = ((java.math.BigInteger) java.math.BigInteger.ZERO);
		boolean _temp1 = true;
		while (_temp1) {
			_temp1 = (!st.gravel.support.jvm.ReadStreamExtensions.atEnd(_stream)) && new st.gravel.support.jvm.Predicate0() {

				@Override
				public boolean value() {
					final int _v;
					_v = st.gravel.support.jvm.CharacterExtensions.digitValue(st.gravel.support.jvm.ReadStreamExtensions.peek(_stream));
					return (_v >= 0) && (_v <= _base);
				}
			}.value();
			if (_temp1) {
				_value = st.gravel.support.jvm.LargeIntegerExtensions.plus_(st.gravel.support.jvm.LargeIntegerExtensions.multiply_(_value, _base), st.gravel.support.jvm.CharacterExtensions.digitValue(st.gravel.support.jvm.ReadStreamExtensions.next(_stream)));
			}
		}
		return _value;
	}

	public PragmaNode readPragma() {
		String _res;
		this.eatWhitespace();
		_res = this.parseIdentifier();
		st.gravel.support.jvm.ObjectExtensions.assert_(this, _res != null);
		if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ':')) {
			String _sel;
			Expression[] _arguments;
			_sel = _res + ':';
			Parser.this.eatWhitespace();
			_arguments = st.gravel.support.jvm.ArrayFactory.with_(Parser.this.parseOperand());
			Parser.this.eatWhitespace();
			_res = Parser.this.parseIdentifier();
			boolean _temp1 = false;
			while (!_temp1) {
				_temp1 = _res == null;
				if (!_temp1) {
					st.gravel.support.jvm.ObjectExtensions.assert_(Parser.this, st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, ':'));
					_sel = _sel + _res + ':';
					Parser.this.eatWhitespace();
					_arguments = st.gravel.support.jvm.ArrayExtensions.copyWith_(_arguments, Parser.this.parseOperand());
					Parser.this.eatWhitespace();
					_res = Parser.this.parseIdentifier();
				}
			}
			st.gravel.support.jvm.ObjectExtensions.assert_(Parser.this, st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '>'));
			return PragmaNode.factory.expression_(KeywordMessageNode.factory.receiver_selector_arguments_(NilLiteralNode.factory.basicNew(), _sel, _arguments));
		} else {
			Parser.this.eatWhitespace();
			st.gravel.support.jvm.ObjectExtensions.assert_(Parser.this, st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '>'));
			return PragmaNode.factory.expression_(UnaryMessageNode.factory.receiver_selector_(NilLiteralNode.factory.basicNew(), _res));
		}
	}

	public PragmaNode[] readPragmas() {
		PragmaNode[] _pragmas;
		_pragmas = new PragmaNode[] {};
		this.eatWhitespace();
		boolean _temp1 = true;
		while (_temp1) {
			_temp1 = st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '<');
			if (_temp1) {
				_pragmas = st.gravel.support.jvm.ArrayExtensions.copyWith_(_pragmas, Parser.this.readPragma());
				Parser.this.eatWhitespace();
			}
		}
		return _pragmas;
	}

	public String readString() {
		final StringBuilder _str;
		_str = st.gravel.support.jvm.WriteStreamFactory.on_(new String());
		st.gravel.support.jvm.ReadStreamExtensions.next(_stream);
		boolean _temp1 = false;
		while (!_temp1) {
			_temp1 = st.gravel.support.jvm.ReadStreamExtensions.atEnd(_stream);
			if (!_temp1) {
				if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '\'')) {
					if (st.gravel.support.jvm.ReadStreamExtensions.peekFor_(_stream, '\'')) {
						_str.append('\'');
					} else {
						return _str.toString();
					}
				} else {
					_str.append(st.gravel.support.jvm.ReadStreamExtensions.next(_stream));
				}
			}
		}
		throw ParseError.factory.basicNew();
	}

	public Node setSourcePosition_node_(final int _start, final Node _aNode) {
		final int _stop;
		if (_sourceFile == null) {
			return _aNode;
		}
		if (_aNode == null) {
			return null;
		}
		_stop = st.gravel.support.jvm.ReadStreamExtensions.position(_stream);
		return _aNode.withSourcePosition_(_sourceFile.from_to_(_start, _stop));
	}

	public java.nio.CharBuffer stream() {
		return _stream;
	}
}