asterix-maven-plugins/lexer-generator-maven-plugin/src/main/resources/Lexer.java

/*
 * Copyright 2009-2013 by The Regents of the University of California
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * you may obtain a copy of the License from
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package [PACKAGE]; 

import java.io.IOException;
import [PACKAGE].[LEXER_NAME]Exception;

public class [LEXER_NAME] {

	public static final int
	TOKEN_EOF = 0, TOKEN_AUX_NOT_FOUND = 1 [TOKENS_CONSTANTS];

	// Human representation of tokens. Useful for debug.
	// Is possible to convert a TOKEN_CONSTANT in its image through
	// [LEXER_NAME].tokenKindToString(TOKEN_CONSTANT); 
	private static final String[] tokenImage = {
		"<EOF>", "<AUX_NOT_FOUND>" [TOKENS_IMAGES]
	};

	private static final char EOF_CHAR = 4;
	protected java.io.Reader inputStream;
	protected int column;
	protected int line;
	protected boolean prevCharIsCR;
	protected boolean prevCharIsLF;
	protected char[] buffer;
	protected int bufsize;
	protected int bufpos;
	protected int tokenBegin;
	protected int endOf_USED_Buffer;
	protected int endOf_UNUSED_Buffer;
	protected int maxUnusedBufferSize;

	// ================================================================================
	//  Auxiliary functions. Can parse the tokens used in the grammar as partial/auxiliary
	// ================================================================================

	[LEXER_AUXFUNCTIONS]

			// ================================================================================
			//  Main method. Return a TOKEN_CONSTANT
			// ================================================================================            

			public int next() throws [LEXER_NAME]Exception, IOException{
		char currentChar = buffer[bufpos];
		while (currentChar == ' ' || currentChar=='\t' || currentChar == '\n' || currentChar=='\r')
			currentChar = readNextChar(); 
		tokenBegin = bufpos;
		if (currentChar==EOF_CHAR) return TOKEN_EOF;

		[LEXER_LOGIC]
	}

	//used when done with stream, must be called exiplicitly now.
	public void close()throws IOException
	{
		inputStream.close();
	}

	//used before processing a new patch in the inputStream
	public void reset(){
		bufpos = endOf_USED_Buffer = 0;         // -- -- -- reuse the buffer
	}

	// ================================================================================
	//  Public interface
	// ================================================================================

	public [LEXER_NAME](java.io.Reader stream) throws IOException{
		reInit(stream);
	}

	public void reInit(java.io.Reader stream) throws IOException{
		done();
		inputStream    = stream;
		bufsize        = 4096;
		line           = 1;
		column         = 0;
		bufpos         = -1;
		endOf_UNUSED_Buffer = bufsize;
		endOf_USED_Buffer = 0;
		prevCharIsCR   = false;
		prevCharIsLF   = false;
		buffer         = new char[bufsize];
		tokenBegin     = -1;
		maxUnusedBufferSize = 4096/2;
		readNextChar();
	}

	public String getLastTokenImage() {
		if (bufpos >= tokenBegin)
			return new String(buffer, tokenBegin, bufpos - tokenBegin);
		else
			return new String(buffer, tokenBegin, bufsize - tokenBegin) +
					new String(buffer, 0, bufpos);
	}

	public static String tokenKindToString(int token) {
		return tokenImage[token]; 
	}

	public void done(){
		buffer = null;
	}

	// ================================================================================
			//  Parse error management
			// ================================================================================    

	protected int parseError(String reason) throws [LEXER_NAME]Exception {
		StringBuilder message = new StringBuilder();
		message.append(reason).append("\n");
		message.append("Line: ").append(line).append("\n");
		message.append("Row: ").append(column).append("\n");
		throw new [LEXER_NAME]Exception(message.toString());
	}

	protected int parseError(int ... tokens) throws [LEXER_NAME]Exception {
		StringBuilder message = new StringBuilder();
		message.append("Error while parsing. ");
		message.append(" Line: ").append(line);
		message.append(" Row: ").append(column);
		message.append(" Expecting:");
		for (int tokenId : tokens){
			message.append(" ").append([LEXER_NAME].tokenKindToString(tokenId));
		}
		throw new [LEXER_NAME]Exception(message.toString());
	}

	protected void updateLineColumn(char c){
		column++;

		if (prevCharIsLF)
		{
			prevCharIsLF = false;
			line += (column = 1);
		}
		else if (prevCharIsCR)
		{
			prevCharIsCR = false;
			if (c == '\n')
			{
				prevCharIsLF = true;
			}
			else
			{
				line += (column = 1);
			}
		}

		if (c=='\r') {
			prevCharIsCR = true;
		} else if(c == '\n') {
			prevCharIsLF = true;
		}
	}

	// ================================================================================
	//  Read data, buffer management. It uses a circular (and expandable) buffer
	// ================================================================================    

	protected char readNextChar() throws IOException {
		if (++bufpos >= endOf_USED_Buffer)
			fillBuff();
		char c = buffer[bufpos];
		updateLineColumn(c);
		return c;
	}

	protected boolean fillBuff() throws IOException {
		if (endOf_UNUSED_Buffer == endOf_USED_Buffer) // If no more unused buffer space 
		{
			if (endOf_UNUSED_Buffer == bufsize)         // -- If the previous unused space was
			{                                           // -- at the end of the buffer
				if (tokenBegin > maxUnusedBufferSize)     // -- -- If the first N bytes before
				{                                         //       the current token are enough
					bufpos = endOf_USED_Buffer = 0;         // -- -- -- setup buffer to use that fragment 
					endOf_UNUSED_Buffer = tokenBegin;
				}
				else if (tokenBegin < 0)                  // -- -- If no token yet
					bufpos = endOf_USED_Buffer = 0;         // -- -- -- reuse the whole buffer
				else
					ExpandBuff(false);                      // -- -- Otherwise expand buffer after its end
			}
			else if (endOf_UNUSED_Buffer > tokenBegin)  // If the endOf_UNUSED_Buffer is after the token
				endOf_UNUSED_Buffer = bufsize;            // -- set endOf_UNUSED_Buffer to the end of the buffer
			else if ((tokenBegin - endOf_UNUSED_Buffer) < maxUnusedBufferSize)
			{                                           // If between endOf_UNUSED_Buffer and the token
				ExpandBuff(true);                         // there is NOT enough space expand the buffer                          
			}                                           // reorganizing it
			else 
				endOf_UNUSED_Buffer = tokenBegin;         // Otherwise there is enough space at the start
		}                                             // so we set the buffer to use that fragment
		int i;
		if ((i = inputStream.read(buffer, endOf_USED_Buffer, endOf_UNUSED_Buffer - endOf_USED_Buffer)) == -1)
		{
			//moved outside
			//inputStream.close();
			buffer[endOf_USED_Buffer]=(char)EOF_CHAR;
			endOf_USED_Buffer++;
			return false;
		}
		else
			endOf_USED_Buffer += i;
		return true;
	}


	protected void ExpandBuff(boolean wrapAround)
	{
		char[] newbuffer = new char[bufsize + maxUnusedBufferSize];

		try {
			if (wrapAround) {
				System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
				System.arraycopy(buffer, 0, newbuffer, bufsize - tokenBegin, bufpos);
				buffer = newbuffer;
				endOf_USED_Buffer = (bufpos += (bufsize - tokenBegin));
			}
			else {
				System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
				buffer = newbuffer;
				endOf_USED_Buffer = (bufpos -= tokenBegin);
			}
		} catch (Throwable t) {
			throw new Error(t.getMessage());
		}

		bufsize += maxUnusedBufferSize;
		endOf_UNUSED_Buffer = bufsize;
		tokenBegin = 0;
	}    
}