org.goko.core.rs274ngcv3.parser.GCodeLexer.java Source code

Introduction

Here is the source code for org.goko.core.rs274ngcv3.parser.GCodeLexer.java

Source

/*******************************************************************************
 *    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);
    }
}