RegExParser.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2023 The Gridarta Developers.
 *
 * This program 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 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
package net.sf.gridarta.var.crossfire.model.validation.checks;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.jetbrains.annotations.NotNull;
 
public class RegExParser {
 
    @NotNull
    private static final Pattern PATTERN_UPPER_CASE_LETTER = Pattern.compile("[A-Z]");
 
    @NotNull
    private final Collection<String> words = new ArrayList<>();
 
    @SuppressWarnings("CharacterComparison")
    public void parse(@NotNull final String regEx, @NotNull final ErrorGenerator<?, ?, ?> generator) {
        words.clear();
 
        for (final char ch : regEx.toCharArray()) {
            if (ch < 32 || ch >= 128) {
                generator.errorRegEx("non-ASCII character"); // works in Crossfire but probably will not work reliably in all clients
            }
        }
 
        int pos = 0;
        int wordIndex = 0;
        final boolean[] range = new boolean[128];
        while (pos < regEx.length()) {
            final char ch = regEx.charAt(pos++);
            switch (ch) {
            case '?':
                generator.errorRegEx("use of regular expression operator '?'. This is usually not useful and therefore should be avoided");
                break;
 
            case '*':
                generator.errorRegEx("use of regular expression operator '*'. This is usually not useful and therefore should be avoided");
                break;
 
            case '+':
                generator.errorRegEx("use of regular expression operator '+'. This is usually not useful and therefore should be avoided");
                break;
 
            case '.':
                generator.errorRegEx("use of regular expression operator '.'. This is usually not useful and therefore should be avoided");
                break;
 
            case '[':
                if (pos < regEx.length() && regEx.charAt(pos) == '^') {
                    generator.errorRegEx("negated character range"); // works in Crossfire but is not useful
                }
                Arrays.fill(range, false);
                final int beginIndex = pos - 1;
                boolean reportError = true;
                while (pos < regEx.length() && regEx.charAt(pos) != ']') {
                    final char begin = regEx.charAt(pos++);
                    if (pos < regEx.length() && regEx.charAt(pos) == '-') {
                        pos++;
                        if (pos >= regEx.length()) {
                            break;
                        }
                        final char end = regEx.charAt(pos++);
                        if (end == ']') {
                            generator.errorRegEx("confusing trailing '-' in character range"); // works in Crossfire but is very confusing
                            reportError = false;
                            pos--;
                            break;
                        }
                        final boolean ok;
                        if ('a' <= begin && begin <= 'z' && 'a' <= end && end <= 'z') {
                            ok = true;
                        } else if ('A' <= begin && begin <= 'Z' && 'A' <= end && end <= 'Z') {
                            ok = true;
                        } else if ('0' <= begin && begin <= '9' && '0' <= end && end <= '9') {
                            ok = true;
                        } else {
                            generator.errorRegEx("character ranges should use only a-z, A-Z, or 0-9");
                            reportError = false;
                            ok = false;
                        }
                        if (ok) {
                            if (begin > end) {
                                generator.errorRegEx("invalid character range");
                                reportError = false;
                            } else if (begin == end) {
                                generator.errorRegEx("single-character character range"); // works in Crossfire but is useless
                                reportError = false;
                            }
                            for (char tmp = begin; tmp <= end; tmp++) {
                                if (range[tmp]) {
                                    generator.errorRegEx("duplicate character '" + tmp + "' in character range");
                                    reportError = false;
                                    break;
                                }
                                range[tmp] = true;
                            }
                        }
                    } else {
                        if (range[begin]) {
                            generator.errorRegEx("duplicate character '" + begin + "' in character range");
                            reportError = false;
                        }
                        range[begin] = true;
                    }
                }
                if (pos >= regEx.length()) {
                    generator.errorRegEx("unterminated character range");
                    break;
                }
                pos++;
                if (reportError) {
                    int i;
                    for (i = 32; i < range.length; i++) {
                        if (range[i]) {
                            break;
                        }
                    }
                    if (i >= 128) {
                        generator.errorRegEx("empty character range"); // works in Crossfire but is useless
                    } else {
                        int j;
                        for (j = i + 1; j < range.length; j++) {
                            if (range[j]) {
                                break;
                            }
                        }
                        if (j >= 128 && i != '?' && i != '*' && i != '+' && i != '.' && i != '[' && i != '\\' && i != '^' && i != '$' && i != '|') {
                            generator.errorRegEx("the word '" + regEx + "' is the same as '" + regEx.substring(0, beginIndex) + (char) i + regEx.substring(pos) + "' which is probably not what was intended"); // useless
                        }
                    }
                }
                break;
 
            case '\\':
                //noinspection SimplifiableIfStatement
                if (pos >= regEx.length()) {
                    generator.errorRegEx("trailing \\");
                } else {
                    generator.errorRegEx("use of regular expression operator '\\'. This is usually not useful and therefore should be avoided");
                }
                pos++;
                break;
 
            case '^':
                if (pos != 1) {
                    generator.errorRegEx("the regular expression operator '^' must be used at the start of the word");
                }
                break;
 
            case '$':
                if (pos != regEx.length()) {
                    generator.errorRegEx("the regular expression operator '$' must be used at the end of the word");
                }
                break;
 
            case '|':
                addWord(regEx.substring(wordIndex, pos - 1), generator);
                wordIndex = pos;
                break;
            }
        }
 
        addWord(regEx.substring(wordIndex), generator);
    }
 
    private void addWord(@NotNull final String word, @NotNull final ErrorGenerator<?, ?, ?> generator) {
        words.add(word);
 
        if (word.startsWith(" ")) {
            generator.errorRegEx("the word '" + word + "' starts with a space");
        } else if (word.endsWith(" ")) {
            generator.errorRegEx("the word '" + word + "' ends with a space");
        }
        final Matcher matcher = PATTERN_UPPER_CASE_LETTER.matcher(word);
        if (matcher.find()) {
            generator.errorRegEx("the word '" + word + "' checks for upper-case letters. Matches are case-insensitive, therefore matches should be specified in lower-case letters only");
        }
    }
 
    @NotNull
    public Collection<String> getWords() {
        return Collections.unmodifiableCollection(words);
    }
 
}