GCodeLexer.java

/*******************************************************************************
 * 	This file is part of Goko.
 *
 *   Goko is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   Goko 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 General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with Goko.  If not, see <http://www.gnu.org/licenses/>.
 *******************************************************************************/
package org.goko.core.rs274ngcv3.parser;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang3.StringUtils;
import org.goko.core.common.exception.GkException;
import org.goko.core.common.exception.GkFunctionalException;
import org.goko.core.common.exception.GkTechnicalException;

/**
 * GCode file tokenizer
 * @author PsyKo
 *
 */
public class GCodeLexer {
	/** Multi line comment pattern */
	private Pattern multilineCommentPattern;
	/** Simple comment pattern*/
	private Pattern simpleCommentPattern;
	/** Line number pattern */
	private Pattern lineNumberPattern;
	/** Word pattern*/
	private Pattern wordPattern;
	/** White space detection pattern*/
	private Pattern spacePattern;

	/**
	 * Constructor
	 */
	public GCodeLexer() {
		multilineCommentPattern = Pattern.compile(GCodeTokenType.MULTILINE_COMMENT.getPattern(), Pattern.MULTILINE | Pattern.DOTALL);
		simpleCommentPattern    = Pattern.compile(GCodeTokenType.SIMPLE_COMMENT.getPattern());
		lineNumberPattern = Pattern.compile(GCodeTokenType.LINE_NUMBER.getPattern());
		wordPattern    = Pattern.compile(GCodeTokenType.WORD.getPattern());
		spacePattern    = Pattern.compile("^[ ]+");
	}
	/**
	 * Create a list of token from a String
	 * @param stringCommand the string to extract tokens from
	 * @return a list of {@link GCodeToken}
	 * @throws GkException GkException
	 */
	public List<GCodeToken> createTokens(String stringCommand) throws GkException{
		List<GCodeToken> lstTokens = new ArrayList<GCodeToken>();

		return createTokens(stringCommand, lstTokens);
	}
	/**
	 * Create a list of token from a File
	 * @param filepath the path to the file
	 * @return a list of {@link GCodeToken}
	 * @throws GkException GkException
	 */
	public List<GCodeToken> createTokensFromFile(String filepath) throws GkException{
		File file = new File(filepath);
		try {
			return createTokensFromInputStream(new FileInputStream(file));
		} catch (FileNotFoundException e) {
			throw new GkTechnicalException(e);
		}
	}

	public List<GCodeToken> createTokensFromInputStream(InputStream inStream) throws GkException{
		Scanner scanner = new Scanner(inStream);

		List<GCodeToken> lstFileTokens = new ArrayList<GCodeToken>();
		String line = null;
		GCodeToken newLineToken = new GCodeToken(GCodeTokenType.NEW_LINE, StringUtils.EMPTY);

		while(scanner.hasNextLine()){
			line = scanner.nextLine();
			lstFileTokens.addAll(createTokens(line));
			lstFileTokens.add(newLineToken);//new GCodeToken(GCodeTokenType.NEW_LINE, StringUtils.EMPTY));
		}

		scanner.close();
		return lstFileTokens;
	}
	/**
	 * Recursive method used to split the stringCommand into a list of tokens
	 * @param stringCommand the string command
	 * @param tokens the list of token
	 * @throws GkException GkException
	 */
	protected List<GCodeToken> createTokens(String stringCommand, List<GCodeToken> tokens) throws GkException{
		if(StringUtils.isBlank(stringCommand)){
			return tokens;
		}
		Matcher spaceMatcher    = spacePattern.matcher(stringCommand);
		if(spaceMatcher.find()){
			String remainingString = spaceMatcher.replaceFirst(StringUtils.EMPTY);
			return createTokens(remainingString,tokens);
		}
		Matcher wordMatcher    = wordPattern.matcher(stringCommand);
		if(wordMatcher.find()){
			String remainingString = extractToken(wordMatcher, tokens, GCodeTokenType.WORD);
			return createTokens(remainingString,tokens);
		}
		Matcher lineNumberMatcher    = lineNumberPattern.matcher(stringCommand);
		if(lineNumberMatcher.find()){
			String remainingString = extractToken(lineNumberMatcher, tokens, GCodeTokenType.LINE_NUMBER);
			return createTokens(remainingString,tokens);
		}
		Matcher multilineCommentMatcher = multilineCommentPattern.matcher(stringCommand);
		if(multilineCommentMatcher.find()){
			String remainingString = extractToken(multilineCommentMatcher, tokens, GCodeTokenType.MULTILINE_COMMENT);
			return createTokens(remainingString,tokens);
		}
		Matcher simpleCommentMatcher    = simpleCommentPattern.matcher(stringCommand);
		if(simpleCommentMatcher.find()){
			String remainingString = extractToken(simpleCommentMatcher, tokens,GCodeTokenType.SIMPLE_COMMENT);
			return createTokens(remainingString,tokens);
		}
		throw new GkFunctionalException("Unexpected character : "+stringCommand);
	}
	/**
	 * Extract the first token from the given matcher
	 * @param matcher the matcher
	 * @param tokens the list of tokens
	 * @param type the type of token to create
	 * @return the remaining String after the token extraction
	 */
	protected String extractToken(Matcher matcher, List<GCodeToken> tokens, GCodeTokenType type){
		tokens.add( new GCodeToken(type, matcher.group()) );
		return matcher.replaceFirst(StringUtils.EMPTY);
	}
}