diff options
Diffstat (limited to 'src/main/java/bjc/rgens/parser/elements')
8 files changed, 219 insertions, 23 deletions
diff --git a/src/main/java/bjc/rgens/parser/elements/CaseElement.java b/src/main/java/bjc/rgens/parser/elements/CaseElement.java index d74ab52..522de7a 100755 --- a/src/main/java/bjc/rgens/parser/elements/CaseElement.java +++ b/src/main/java/bjc/rgens/parser/elements/CaseElement.java @@ -1,17 +1,14 @@ package bjc.rgens.parser.elements; +import bjc.rgens.parser.GenerationState; import bjc.rgens.parser.GrammarException; -/* - * @TODO 10/11/17 Ben Culkin :CaseElementSplit Split this into multiple - * subclasses based off of a value of ElementType. - */ /** * A element in a rule case. * * @author EVE */ -public class CaseElement { +public abstract class CaseElement { /** * The possible types of an element. * @@ -34,8 +31,6 @@ public class CaseElement { } /* Regexps for marking rule types. */ - private static final String SPECIAL_CASELEM = "\\{[^}]+\\}"; - private static final String REFER_CASELEM = "\\[[^\\]]+\\]"; private static final String RANGE_CASELM = "\\[\\d+\\.\\.\\d+\\]"; /** The type of this element. */ @@ -53,13 +48,18 @@ public class CaseElement { @Override public String toString() { - switch (type) { - default: - return String.format("Unknown type '%s'", type); - } + return String.format("Unknown type '%s'", type); } /** + * Generate this case element. + * + * @param state + * The current state of generation. + */ + public abstract void generate(GenerationState state); + + /** * Create a case element from a string. * * @param csepart @@ -72,8 +72,11 @@ public class CaseElement { throw new NullPointerException("Case part cannot be null"); } - if (csepart.matches(SPECIAL_CASELEM)) { - /* Handle special cases. */ + if (csepart.matches("\\{[^}]+\\}")) { + /* + * Handle special cases. + * + */ String specialBody = csepart.substring(1, csepart.length() - 1); System.out.printf("\t\tTRACE: special body is '%s'\n", specialBody); @@ -88,6 +91,12 @@ public class CaseElement { throw new GrammarException(msg); } + /* + * @NOTE + * + * This should maybe check that parts[1] is a + * valid rule name, since it gets used as one. + */ return new ExpVariableCaseElement(parts[0], parts[1]); } else if (specialBody.matches("\\S+=\\S+")) { /* Handle regular variable definitions. */ @@ -100,23 +109,28 @@ public class CaseElement { } return new LitVariableCaseElement(parts[0], parts[1]); - } else if (specialBody.matches("{empty}")) { + } else if (specialBody.matches("empty")) { /* Literal blank, for empty cases. */ return new BlankCaseElement(); } else { throw new IllegalArgumentException(String.format("Unknown special case part '%s'", specialBody)); } - } else if (csepart.matches(REFER_CASELEM)) { - if (csepart.matches(RANGE_CASELM)) { - /* Handle ranges */ - String rawRange = csepart.substring(1, csepart.length() - 1); + } else if (csepart.matches("\\[[^\\]]+\\]")) { + String rawCase = csepart.substring(1, csepart.length() - 1); - int firstNum = Integer.parseInt(rawRange.substring(0, rawRange.indexOf('.'))); - int secondNum = Integer.parseInt(rawRange.substring(rawRange.lastIndexOf('.') + 1)); + if (rawCase.matches("\\d+\\.\\.\\d+")) { + int firstNum = Integer.parseInt(rawCase.substring(0, rawCase.indexOf('.'))); + int secondNum = Integer.parseInt(rawCase.substring(rawCase.lastIndexOf('.') + 1)); return new RangeCaseElement(firstNum, secondNum); } + /* + * @NOTE + * + * Once the rule element execution has been refactored, + * pass rawCase instead. + */ return new RuleCaseElement(csepart); } else { return new LiteralCaseElement(csepart); @@ -144,4 +158,4 @@ public class CaseElement { return false; return true; } -}
\ No newline at end of file +} diff --git a/src/main/java/bjc/rgens/parser/elements/ExpVariableCaseElement.java b/src/main/java/bjc/rgens/parser/elements/ExpVariableCaseElement.java index 30925e2..8598fbd 100755 --- a/src/main/java/bjc/rgens/parser/elements/ExpVariableCaseElement.java +++ b/src/main/java/bjc/rgens/parser/elements/ExpVariableCaseElement.java @@ -1,7 +1,45 @@ package bjc.rgens.parser.elements; +import bjc.rgens.parser.GenerationState; +import bjc.rgens.parser.GrammarException; +import bjc.rgens.parser.RGrammar; +import bjc.rgens.parser.RuleCase; + public class ExpVariableCaseElement extends VariableCaseElement { public ExpVariableCaseElement(String name, String def) { super(name, def, true); } + + @Override + public void generate(GenerationState state) { + GenerationState newState = state.newBuf(); + + if (state.rules.containsKey(varDef)) { + RuleCase destCase = state.rules.get(varDef).getCase(); + + state.gram.generateCase(destCase, newState); + } else if (state.importRules.containsKey(varDef)) { + RGrammar destGrammar = state.importRules.get(varDef); + + newState.swapGrammar(destGrammar); + + String res = destGrammar.generate(varDef, state); + + /* + * @NOTE + * + * :Postprocessing + * + * This is because generate() returns a processed + * string, but modifies the passed in StringBuilder. + */ + newState.contents = new StringBuilder(res); + } else { + String msg = String.format("No rule '%s' defined", varDef); + throw new GrammarException(msg); + } + + state.vars.put(varName, newState.contents.toString()); + + } } diff --git a/src/main/java/bjc/rgens/parser/elements/LitVariableCaseElement.java b/src/main/java/bjc/rgens/parser/elements/LitVariableCaseElement.java index 11035b1..91b8a2b 100755 --- a/src/main/java/bjc/rgens/parser/elements/LitVariableCaseElement.java +++ b/src/main/java/bjc/rgens/parser/elements/LitVariableCaseElement.java @@ -1,7 +1,13 @@ package bjc.rgens.parser.elements; +import bjc.rgens.parser.GenerationState; + public class LitVariableCaseElement extends VariableCaseElement { public LitVariableCaseElement(String name, String def) { super(name, def, false); } + + public void generate(GenerationState state) { + state.vars.put(varName, varDef); + } } diff --git a/src/main/java/bjc/rgens/parser/elements/LiteralCaseElement.java b/src/main/java/bjc/rgens/parser/elements/LiteralCaseElement.java index d96a32d..18c3482 100755 --- a/src/main/java/bjc/rgens/parser/elements/LiteralCaseElement.java +++ b/src/main/java/bjc/rgens/parser/elements/LiteralCaseElement.java @@ -1,7 +1,14 @@ package bjc.rgens.parser.elements; +import bjc.rgens.parser.GenerationState; + public class LiteralCaseElement extends StringCaseElement { public LiteralCaseElement(String vl) { super(vl, true); } + + @Override + public void generate(GenerationState state) { + state.contents.append(val); + } } diff --git a/src/main/java/bjc/rgens/parser/elements/RangeCaseElement.java b/src/main/java/bjc/rgens/parser/elements/RangeCaseElement.java index d98bc61..7cebde9 100755 --- a/src/main/java/bjc/rgens/parser/elements/RangeCaseElement.java +++ b/src/main/java/bjc/rgens/parser/elements/RangeCaseElement.java @@ -1,5 +1,7 @@ package bjc.rgens.parser.elements; +import bjc.rgens.parser.GenerationState; + public class RangeCaseElement extends CaseElement { public final int begin; public final int end; @@ -11,6 +13,13 @@ public class RangeCaseElement extends CaseElement { end = en; } + public void generate(GenerationState state) { + int val = state.rnd.nextInt(end - begin); + val += begin; + + state.contents.append(val); + } + @Override public int hashCode() { final int prime = 31; diff --git a/src/main/java/bjc/rgens/parser/elements/RuleCaseElement.java b/src/main/java/bjc/rgens/parser/elements/RuleCaseElement.java index f4d3512..d91bebc 100755 --- a/src/main/java/bjc/rgens/parser/elements/RuleCaseElement.java +++ b/src/main/java/bjc/rgens/parser/elements/RuleCaseElement.java @@ -1,7 +1,129 @@ package bjc.rgens.parser.elements; +import bjc.rgens.parser.*; + +import java.util.regex.Matcher; +import java.util.regex.Pattern; + public class RuleCaseElement extends StringCaseElement { + private static Pattern NAMEVAR_PATTERN = Pattern.compile("\\$(\\w+)"); + public RuleCaseElement(String vl) { super(vl, false); } + + @Override + public void generate(GenerationState state) { + /* + * @NOTE + * + * :VarRefactor + * + * Figure out if this can be refactored in some way. + */ + String refersTo = val; + + GenerationState newState = state.newBuf(); + + if (refersTo.contains("$")) { + /* Parse variables */ + String refBody = refersTo.substring(1, refersTo.length() - 1); + + if (refBody.contains("-")) { + /* Handle dependent rule names. */ + StringBuffer nameBuffer = new StringBuffer(); + + Matcher nameMatcher = NAMEVAR_PATTERN.matcher(refBody); + + while (nameMatcher.find()) { + String var = nameMatcher.group(1); + + if (!state.vars.containsKey(var)) { + String msg = String.format("No variable '%s' defined", var); + throw new GrammarException(msg); + } + + String name = state.vars.get(var); + + if (name.contains(" ")) { + throw new GrammarException("Variables substituted into names cannot contain spaces"); + } else if (name.equals("")) { + throw new GrammarException("Variables substituted into names cannot be empty"); + } + + nameMatcher.appendReplacement(nameBuffer, name); + } + + nameMatcher.appendTail(nameBuffer); + + refersTo = "[" + nameBuffer.toString() + "]"; + } else { + /* Handle string references. */ + if (refBody.equals("$")) { + throw new GrammarException("Cannot refer to unnamed variables"); + } + + String key = refBody.substring(1); + + if (!state.vars.containsKey(key)) { + String msg = String.format("No variable '%s' defined", key); + throw new GrammarException(msg); + } + + state.contents.append(state.vars.get(key)); + + return; + } + } + + if (refersTo.startsWith("[^")) { + refersTo = "[" + refersTo.substring(2); + + RGrammar dst = state.importRules.get(refersTo); + + newState.swapGrammar(dst); + + /* :Postprocessing */ + newState.contents = new StringBuilder(dst.generate(refersTo, state.rnd, state.vars)); + } else if (state.rules.containsKey(refersTo)) { + RuleCase cse = state.rules.get(refersTo).getCase(state.rnd); + + state.gram.generateCase(cse, newState); + } else if (state.importRules.containsKey(refersTo)) { + RGrammar dst = state.importRules.get(refersTo); + + newState.swapGrammar(dst); + + /* :Postprocessing */ + newState.contents = new StringBuilder(dst.generate(refersTo, state.rnd, state.vars)); + } else { + /* + * @TODO 5/29/18 Ben Culkin :RuleSuggesting + * + * Re-get this working again. + */ + /* + if (ruleSearcher != null) { + Set<Match<? extends String>> results = ruleSearcher.search(refersTo, MAX_DISTANCE); + + String[] resArray = results.stream().map(Match::getMatch).toArray((i) -> new String[i]); + + String msg = String.format("No rule '%s' defined (perhaps you meant %s?)", refersTo, + StringUtils.toEnglishList(resArray, false)); + + throw new GrammarException(msg); + } + */ + + String msg = String.format("No rule '%s' defined", refersTo); + throw new GrammarException(msg); + } + + if (refersTo.contains("+")) { + /* Rule names with pluses in them get space-flattened */ + state.contents.append(newState.contents.toString().replaceAll("\\s+", "")); + } else { + state.contents.append(newState.contents.toString()); + } + } } diff --git a/src/main/java/bjc/rgens/parser/elements/StringCaseElement.java b/src/main/java/bjc/rgens/parser/elements/StringCaseElement.java index 0e64fd3..61ad48a 100755 --- a/src/main/java/bjc/rgens/parser/elements/StringCaseElement.java +++ b/src/main/java/bjc/rgens/parser/elements/StringCaseElement.java @@ -1,6 +1,6 @@ package bjc.rgens.parser.elements; -public class StringCaseElement extends CaseElement { +public abstract class StringCaseElement extends CaseElement { public final String val; protected StringCaseElement(String vl, boolean isLiteral) { diff --git a/src/main/java/bjc/rgens/parser/elements/VariableCaseElement.java b/src/main/java/bjc/rgens/parser/elements/VariableCaseElement.java index 920445a..3e691d9 100755 --- a/src/main/java/bjc/rgens/parser/elements/VariableCaseElement.java +++ b/src/main/java/bjc/rgens/parser/elements/VariableCaseElement.java @@ -1,6 +1,6 @@ package bjc.rgens.parser.elements; -public class VariableCaseElement extends CaseElement { +public abstract class VariableCaseElement extends CaseElement { /** * The name of the variable this element defines. */ |