From e9e0ca7bfe722375e7ccb25d2bafbe395b6c6a59 Mon Sep 17 00:00:00 2001 From: Ben Culkin Date: Tue, 6 Oct 2020 19:16:26 -0400 Subject: Info cleanup --- .../elements/vars/LiteralVariableElement.java | 16 +++++ .../parser/elements/vars/RRefVariableElement.java | 15 +++++ .../parser/elements/vars/TRefVariableElement.java | 2 + .../parser/elements/vars/VRefVariableElement.java | 15 +++++ .../parser/elements/vars/VariableElement.java | 70 ++++++++++++++++++---- 5 files changed, 106 insertions(+), 12 deletions(-) (limited to 'src/main/java/bjc/rgens/parser/elements/vars') diff --git a/src/main/java/bjc/rgens/parser/elements/vars/LiteralVariableElement.java b/src/main/java/bjc/rgens/parser/elements/vars/LiteralVariableElement.java index e7415f5..595397b 100644 --- a/src/main/java/bjc/rgens/parser/elements/vars/LiteralVariableElement.java +++ b/src/main/java/bjc/rgens/parser/elements/vars/LiteralVariableElement.java @@ -2,15 +2,31 @@ package bjc.rgens.parser.elements.vars; import bjc.rgens.parser.GenerationState; +/** + * Case element which references a literal variable. + * + * @author Ben Culkin + * + */ public class LiteralVariableElement extends VariableElement { + /** + * The name for the variable. + */ public String val; + /** + * Create a case element which references a literal variable. + * + * @param forbidSpaces Whether to forbid spaces in the result. + * @param val The name of the literal variable. + */ public LiteralVariableElement(boolean forbidSpaces, String val) { super(forbidSpaces); this.val = val; } + @Override public void generate(GenerationState state) { state.appendContents(val); } diff --git a/src/main/java/bjc/rgens/parser/elements/vars/RRefVariableElement.java b/src/main/java/bjc/rgens/parser/elements/vars/RRefVariableElement.java index e81e9f8..4001b93 100644 --- a/src/main/java/bjc/rgens/parser/elements/vars/RRefVariableElement.java +++ b/src/main/java/bjc/rgens/parser/elements/vars/RRefVariableElement.java @@ -4,15 +4,30 @@ import bjc.rgens.parser.GenerationState; import bjc.rgens.parser.GrammarException; import bjc.rgens.parser.Rule; +/** + * Rule reference variable element. + * @author Ben Culkin + * + */ public class RRefVariableElement extends VariableElement { + /** + * The name of the rule to reference. + */ public String value; + /** + * Create a new rule-reference variable element. + * + * @param forbidSpaces Whether to forbid spaces or not. + * @param val The rule to reference. + */ public RRefVariableElement(boolean forbidSpaces, String val) { super(forbidSpaces); value = val; } + @Override public void generate(GenerationState state) { Rule rl = state.findRule(value, true); diff --git a/src/main/java/bjc/rgens/parser/elements/vars/TRefVariableElement.java b/src/main/java/bjc/rgens/parser/elements/vars/TRefVariableElement.java index c753dfe..efd9007 100644 --- a/src/main/java/bjc/rgens/parser/elements/vars/TRefVariableElement.java +++ b/src/main/java/bjc/rgens/parser/elements/vars/TRefVariableElement.java @@ -7,6 +7,7 @@ import bjc.rgens.parser.GenerationState; * * finish when template vars are implemented. */ +@SuppressWarnings("javadoc") public class TRefVariableElement extends VariableElement { public String value; @@ -16,6 +17,7 @@ public class TRefVariableElement extends VariableElement { value = val; } + @Override public void generate(GenerationState state) { /* if(!state.rlVars.containsKey(val)) { diff --git a/src/main/java/bjc/rgens/parser/elements/vars/VRefVariableElement.java b/src/main/java/bjc/rgens/parser/elements/vars/VRefVariableElement.java index e65d876..cdead80 100644 --- a/src/main/java/bjc/rgens/parser/elements/vars/VRefVariableElement.java +++ b/src/main/java/bjc/rgens/parser/elements/vars/VRefVariableElement.java @@ -3,15 +3,30 @@ package bjc.rgens.parser.elements.vars; import bjc.rgens.parser.GenerationState; import bjc.rgens.parser.GrammarException; +/** + * Variable reference variable element. + * + * @author Ben Culkin + * + */ public class VRefVariableElement extends VariableElement { + /** + * The name of the variable to element. + */ public final String nam; + /** + * Create a new variable referencing variable element. + * @param forbidSpaces Whether or not to forbid spaces in the element. + * @param nam The name of the variable. + */ public VRefVariableElement(boolean forbidSpaces, String nam) { super(forbidSpaces); this.nam = nam; } + @Override public void generate(GenerationState state) { String strang = state.findVar(nam); diff --git a/src/main/java/bjc/rgens/parser/elements/vars/VariableElement.java b/src/main/java/bjc/rgens/parser/elements/vars/VariableElement.java index eb36af8..c73e249 100644 --- a/src/main/java/bjc/rgens/parser/elements/vars/VariableElement.java +++ b/src/main/java/bjc/rgens/parser/elements/vars/VariableElement.java @@ -7,30 +7,73 @@ import bjc.rgens.parser.GenerationState; import bjc.rgens.parser.GrammarException; import bjc.utils.ioutils.LevelSplitter; +/** + * Case element which references a variable. + * + * @author Ben Culkin + * + */ public abstract class VariableElement { + /** + * Whether or not to forbid spaces in this element. + */ public boolean forbidSpaces; + /** + * Create a new variable element. + * + * @param forbidSpacing + * Whether spacing should be forbidden in this element. + */ protected VariableElement(boolean forbidSpacing) { forbidSpaces = forbidSpacing; } + /** + * Generate this element. + * + * @param state + * The state of generation. + */ public abstract void generate(GenerationState state); + /** + * Parse a variable element from a string. + * + * @param varElm + * The string to parse. + * + * @return The variable elements which make up the string. + */ public static List parseElementString(String varElm) { boolean forbidSpaces = LevelSplitter.def.levelContains(varElm, "-", "+"); String[] parts; - if(forbidSpaces) { - parts = LevelSplitter.def.levelSplit(varElm, true, "-", "+").toArray(new String[0]); + if (forbidSpaces) { + parts = LevelSplitter.def.levelSplit(varElm, true, "-", "+") + .toArray(new String[0]); } else { - parts = new String[] { varElm }; + parts = new String[] { + varElm + }; } return parseElementString(forbidSpaces, parts); } - public static List parseElementString(boolean forbidSpaces, String... parts) { + /** + * Parse a string of variable elements. + * + * @param forbidSpaces + * Whether or not to forbid spacing in this variable. + * @param parts + * The parts to parse into variable elements. + * + * @return The variable elements from the string. + */ + public static List parseElementString(boolean forbidSpaces, + String... parts) { List elms = new ArrayList<>(parts.length); VariableElement prevElement = null; @@ -44,23 +87,26 @@ public abstract class VariableElement { VariableElement elm = null; - if(part.startsWith("$")) { + if (part.startsWith("$")) { elm = new VRefVariableElement(forbidSpaces, part.substring(1)); } else if (part.startsWith("@")) { - if(forbidSpaces) - throw new GrammarException("Arrays references aren't allowed in rule names"); + if (forbidSpaces) + throw new GrammarException( + "Arrays references aren't allowed in rule names"); elm = new ARefVariableElement(part.substring(1)); } else if (part.startsWith("%")) { - elm = new RRefVariableElement(forbidSpaces, String.format("[%s]", part.substring(1))); + elm = new RRefVariableElement(forbidSpaces, + String.format("[%s]", part.substring(1))); } else if (part.startsWith("/")) { throw new GrammarException("Template variables aren't implemented yet"); } else { - if(prevElement != null && prevElement instanceof LiteralVariableElement) { + if (prevElement != null + && prevElement instanceof LiteralVariableElement) { /* Aggregate chain literals together */ - ((LiteralVariableElement)prevElement).val += part; + ((LiteralVariableElement) prevElement).val += part; } else { - if(part.contains(" ")) { + if (part.contains(" ")) { elm = new LiteralVariableElement(false, part); } else { elm = new LiteralVariableElement(true, part); @@ -68,7 +114,7 @@ public abstract class VariableElement { } } - if(elm != null) { + if (elm != null) { elms.add(elm); prevElement = elm; -- cgit v1.2.3