protected static GrammarElement ParseCGE(Grammar.Grammar grammar, string line, string delimiters = "@Default") { CompoundGrammarElement cge = new CompoundGrammarElement(); if (delimiters.Equals("@Default")) { cge.Delimiters = " \n\r\t"; } else if (delimiters.Equals("@None")) { cge.Delimiters = ""; } else { cge.Delimiters = delimiters; } string[] tokens = line.Split(new char[] { ' ', '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries); if (tokens.Length == 1 && grammar.Terminals.ContainsKey(tokens[0])) { return(grammar.Terminals[tokens[0]]); } foreach (string tokenw in tokens) { string token = tokenw.Trim(); if ((token.StartsWith("'") && token.EndsWith("'")) || (token.StartsWith("\"") && token.EndsWith("\"")) || token.StartsWith("ux") || token.StartsWith("u")) { string value = GetSymbolValue(token); LiteralGrammarElement lge = new LiteralGrammarElement(value); cge.AddTerminal(lge); } else if (grammar.Terminals.ContainsKey(token)) { cge.AddTerminal(grammar.Terminals[token]); } else if (token.EndsWith("*")) { string tok = token.Substring(0, token.Length - 1); if (grammar.Terminals.ContainsKey(tok)) { RepetitiveGrammarElement rge = new RepetitiveGrammarElement(grammar.Terminals[tok]); cge.AddTerminal(rge); } } else if (!grammar.Terminals.ContainsKey(token)) { throw new KeyNotFoundException(); } } return(cge); }
protected static void ParseSymbol(ref Grammar.Grammar grammar, string line) { string backup = line; LiteralGrammarElement SymbolKeyword = new LiteralGrammarElement("Symbol "); if (SymbolKeyword.Validate(ref line, true).Result) { line = line.Trim(); string templine = line; SymbolSet AlphabetWithSpace = SymbolSet.FromType(SymbolSetPredefinedType.AlphaNumeric); AlphabetWithSpace.Add(new Symbol('_')); AlphabetWithSpace.Add(new Symbol('$')); VariableLengthGrammarElement SymbolName = new VariableLengthGrammarElement(VariableLengthGrammarElementType.Plus, AlphabetWithSpace); if (SymbolName.Validate(ref line, true).Result) { string name = templine.Substring(0, ((line.Length != 0)?templine.IndexOf(line):templine.Length)).Trim(); line = line.Trim(); LiteralGrammarElement EqualsSign = new LiteralGrammarElement("="); if (EqualsSign.Validate(ref line, true).Result) { line = line.Trim(); try { Symbol symbol = new Symbol(GetSymbolValue(line)); grammar.AddSymbol(name, symbol); } catch (InfinityGrammarScriptParseError ie) { throw new InfinityGrammarScriptParseError("Illegal argument specified as symbol, (enclose in ' ' or \" \")", backup, ie); } } else { throw new InfinityGrammarScriptParseError("Syntax requires a symbol value assignment, which is missing", backup); } } else { throw new InfinityGrammarScriptParseError("The Symbol name specified was not valid. Names given can have Letters, Numbers and $ and _ (underscore)", backup); } } else { throw new InfinityGrammarScriptParseError("Not a Symbol definition", backup); } }
protected static void AddTerminalTo(ref Grammar.Grammar grammar, string line) { string _line = line; LiteralGrammarElement addKeyword = new LiteralGrammarElement("Add"); if (addKeyword.Validate(ref _line, true).Result) { if (_line.IndexOf(" To ") != -1) { string to = _line.Substring(_line.IndexOf("To") + 2).Trim(); if (!grammar.Terminals.ContainsKey(to)) { throw new InfinityGrammarScriptParseError("Terminal not found to perform addition of terminals - " + to, _line); } _line = _line.Substring(0, _line.IndexOf("To")).Trim(); string[] _terminals = _line.Split(new char[] { ' ', ',' }, StringSplitOptions.RemoveEmptyEntries); foreach (string _terminal in _terminals) { if (grammar.Terminals.ContainsKey(_terminal)) { grammar.AddTerminalTo(_terminal, to); } else { throw new InfinityGrammarScriptParseError("No such terminal to add to - " + to + " : " + _terminal, _line); } } } else { throw new InfinityGrammarScriptParseError("Add statement improperly formed. Missing 'To' keyword.", _line); } } else { throw new InfinityGrammarScriptParseError("Please check whether you have typed the correct syntax.", _line); } }
public static ICASMDirective ParseDirective(Scope _currentScope, string statement) { statement = statement.Trim(); LiteralGrammarElement lge = new LiteralGrammarElement("import", "reflect", "ewfc", "+var", "-var", "+pool", "-pool", "+fields", "+field", "-field", "-fields", "+typespace", "-typespace", "+type", "-type", "-all", "+function", "-function", "call", "assign", "jump", "return", "clear", "if", "elseif", "else", "while", "repeat", "end+"); TestResult <bool> directiveKeywordResult = lge.Validate(ref statement, true); string directiveKeyword = (string)directiveKeywordResult["Symbol"]; statement = statement.Trim(); ICASMDirectiveType type = ICASMDirective.GetTypeFromString(directiveKeyword); ICASMTagType tag = ICASMTagType.None; if (statement.StartsWith("-")) { LiteralGrammarElement tagChecker = new LiteralGrammarElement("-help", "-path", "-none", "-suppress", "-temporary", "-random", "-report", "-variable", "-pool", "-type", "-typespace"); TestResult <bool> tagKeywordResult = tagChecker.Validate(ref statement, true); if (tagKeywordResult.Result) { string tagKeyword = (string)tagKeywordResult["Symbol"]; tag = ICASMDirective.GetTagTypeFromString(tagKeyword); } } string innerstatement = null; statement = statement.Trim(); if (type == ICASMDirectiveType.AssignDirective && statement.StartsWith("(")) { innerstatement = statement.Trim().Substring(1, statement.LastIndexOf(')') - 1).Trim(); statement = statement.Substring(statement.LastIndexOf(')') + 1).Trim(); ICASMDirective innerdirective = ICASMInterpreter.ParseDirective(_currentScope, innerstatement); ICASMExecutionResult innerresult = ICASMInterpreter.Execute(_currentScope, innerdirective); if (innerresult.Data.ContainsKey("CallDirective")) { statement = ((Address)innerresult.Data["CallDirective"]).FullPath + " " + statement; } } string[] paramstrs = statement.Trim().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); ICASMDirectiveParameters parameters = new ICASMDirectiveParameters(); string str = ""; bool stringopen = false; foreach (string param in paramstrs) { ICASMValue value = null; if (!stringopen && param.StartsWith("\"") && !param.EndsWith("\"")) { stringopen = true; str = param + " "; } else if (stringopen || (param.StartsWith("\"") && param.EndsWith("\""))) { str = str + param + " "; if (param.EndsWith("\"")) { stringopen = false; value = ICASMValue.ParseValue(str.Trim()); str = ""; } } else { value = ICASMValue.ParseValue(param); } if (value != null) { parameters.Add(value); } } return(new ICASMDirective(type, tag, parameters)); }
public static ICASMValue ParseValue(string value) { value = value.Trim(); bool isType = false; if (value.StartsWith("typeof")) { value = value.Substring(6).Trim(); if (value.StartsWith("(") && value.EndsWith(")")) { value = value.Substring(1, value.Length - 2).Trim(); if (value.Equals("stack")) { return(new ICASMValue(ICASMValueType.Address, RuntimeEngine.GetVariable(ICASMInterpreter.MemoryStack.Peek()).Type.Address.FullPath)); } else if (value.Equals("stackp")) { return(new ICASMValue(ICASMValueType.Address, RuntimeEngine.GetVariable(ICASMInterpreter.MemoryStack.Pop()).Type.Address.FullPath)); } isType = true; } } int intValue; double doubleValue; bool boolValue; if (bool.TryParse(value, out boolValue)) { if (isType) { return(new ICASMValue(ICASMValueType.Address, "/Boolean")); } return(new ICASMValue(ICASMValueType.Normal, boolValue, ICASMPrimitiveDataType.Integer)); } else if (int.TryParse(value, out intValue)) { if (isType) { return(new ICASMValue(ICASMValueType.Address, "/Integer")); } return(new ICASMValue(ICASMValueType.Normal, intValue, ICASMPrimitiveDataType.Integer)); } else if (double.TryParse(value, out doubleValue)) { if (isType) { return(new ICASMValue(ICASMValueType.Address, "/Real")); } return(new ICASMValue(ICASMValueType.Normal, doubleValue, ICASMPrimitiveDataType.Real)); } else if (value.StartsWith("'") && value.EndsWith("'") && value.Length == 3) { if (isType) { return(new ICASMValue(ICASMValueType.Address, "/Character")); } return(new ICASMValue(ICASMValueType.Normal, value[1], ICASMPrimitiveDataType.Character)); } else if (value.StartsWith("\"") && value.EndsWith("\"")) { if (isType) { return(new ICASMValue(ICASMValueType.Address, "/String")); } return(new ICASMValue(ICASMValueType.Normal, value.Substring(1, value.Length - 2), ICASMPrimitiveDataType.String)); } LiteralGrammarElement lge = new LiteralGrammarElement("+var", "-var", "+pool", "-pool", "+type", "-type", "+field", "-field", "+fields", "-fields", "+typespace", "-typespace", "-all", "+function", "-function", "call", "assign", "goto", "return", "clear", "if", "elseif", "else", "while", "repeat", "end+"); string temp = value; if (lge.Validate(ref temp, true).Result) { return(new ICASMValue(ICASMValueType.ExecutableResult, value)); } Grammar checker = Infinity.Scripting.InfinityGrammarScript.LoadGrammar("Symbol Underscore = \"_\"\n" + "SymbolSet Digit = new Digit\n" + "SymbolSet ForwardSlash = [\"/\"]\n" + "SymbolSet IdentifierStartSymbol = new Alphabet, Underscore\n" + "SymbolSet IdentifierContinuationSymbol = new Alphabet, new Digit, Underscore\n" + "SymbolSet DefaultOperators = ['+','-','*','/','%','!','@','#','$','^','&','=','|',':','<','>','?']\n"+ "SymbolSet FunctionIdentifierSymbol = new Alphabet, Underscore, DefaultOperators\n" + "GrammarElement Integer = Digit+\n" + "GrammarElement Identifier = IdentifierStartSymbol IdentifierContinuationSymbol*\n" + "GrammarElement FunctionIdentifier = FunctionIdentifierSymbol FunctionIdentifierSymbol*\n" + "GrammarElement AddressNode = ForwardSlash Identifier\n" + "GrammarElement Root = \"/\"\n" + "GrammarElement PureAddress = AddressNode AddressNode *\n" + "GrammarElement DotIdentifier = \".\" Identifier\n" + "GrammarElement TupleAddress = PureAddress DotIdentifier *\n" + "GrammarElement Address = TupleAddress or PureAddress, precedence: Ascending\n" + "GrammarElement ParameterAccess = \"[\" Integer \"]\" DotIdentifier*\n" + "GrammarElement AddressorRoot = Address or Root, precedence: Ascending\n" + "StartSymbol = AddressorRoot"); temp = value; if (checker.Terminals["AddressorRoot"].Validate(ref temp, true).Result) { if (isType) { return(new ICASMValue(ICASMValueType.Address, RuntimeEngine.GetVariable(value).Type.Address.FullPath)); } return(new ICASMValue(ICASMValueType.Address, value)); } temp = value; if (checker.Terminals["ParameterAccess"].Validate(ref temp, true).Result) { return(new ICASMValue(ICASMValueType.FunctionParameterAccess, value)); } temp = value; if (checker.Terminals["Identifier"].Validate(ref temp, true).Result) { if (value.Equals("stack")) { return(new ICASMValue(ICASMValueType.Address, ICASMInterpreter.MemoryStack.Peek().FullPath)); } else if (value.Equals("stackp")) { return(new ICASMValue(ICASMValueType.Address, ICASMInterpreter.MemoryStack.Pop().FullPath)); } if (isType) { return(new ICASMValue(ICASMValueType.Address, RuntimeEngine.GetVariable("/" + value).Type.Address.FullPath)); } return(new ICASMValue(ICASMValueType.Identifier, value)); } temp = value; if (checker.Terminals["FunctionIdentifier"].Validate(ref temp, true).Result) { return(new ICASMValue(ICASMValueType.FunctionIdentifier, value)); } return(null); }
protected static void ParseMPGE(Grammar.Grammar grammar, string line) { string backup = line; LiteralGrammarElement SymbolKeyword = new LiteralGrammarElement("MultiGrammarElement "); if (SymbolKeyword.Validate(ref line, true).Result) { line = line.Trim(); string templine = line; SymbolSet AlphabetWithSpace = SymbolSet.FromType(SymbolSetPredefinedType.AlphaNumeric); AlphabetWithSpace.Add(new Symbol('_')); AlphabetWithSpace.Add(new Symbol('$')); AlphabetWithSpace.Add(new Symbol('/')); VariableLengthGrammarElement SymbolName = new VariableLengthGrammarElement(VariableLengthGrammarElementType.Plus, AlphabetWithSpace); if (SymbolName.Validate(ref line, true).Result) { string name = templine.Substring(0, templine.IndexOf(line)).Trim(); line = line.Trim(); LiteralGrammarElement EqualsSign = new LiteralGrammarElement("="); if (EqualsSign.Validate(ref line, true).Result) { line = line.Trim(); MultiParsePrecedenceType precedence = MultiParsePrecedenceType.Normal; if (line.LastIndexOf(',') >= 0) { string precedenceString = line.Substring(line.IndexOf(',') + 1).Trim(); line = line.Substring(0, line.IndexOf(',')).Trim(); LiteralGrammarElement precKey = new LiteralGrammarElement("precedence"); LiteralGrammarElement colon = new LiteralGrammarElement(":"); if (precKey.Validate(ref precedenceString, true).Result) { precedenceString = precedenceString.Trim(); if (colon.Validate(ref precedenceString, true).Result) { string[] precedenceList = Enum.GetNames(typeof(MultiParsePrecedenceType)); LiteralGrammarElement type = new LiteralGrammarElement(precedenceList); precedenceString = precedenceString.Trim(); if (type.Validate(ref precedenceString, false).Result) { precedence = (MultiParsePrecedenceType)Enum.Parse(typeof(MultiParsePrecedenceType), precedenceString); } else { throw new InfinityGrammarScriptParseError("Error", backup); } } else { throw new InfinityGrammarScriptParseError("Precedence is always followed by a Colon \":\"", backup); } } else { throw new InfinityGrammarScriptParseError("Invalid syntax. Only 'precedence' keyword allowed here", backup); } } string[] terminals = line.Split(new string[] { " or ", " | " }, StringSplitOptions.RemoveEmptyEntries); MultiParseGrammarElement mpge = new MultiParseGrammarElement(); mpge.Precedence = precedence; int count = 0; foreach (string ss in terminals) { try { GrammarElement cge = ParseCGE(grammar, ss); if (cge.Name == null || cge.Name == "") { cge.Name = name + ":" + count++; } mpge.AddTerminal(cge); } catch (KeyNotFoundException) { _temp.Add(backup); throw new InfinityGrammarScriptParseError("No such terminal to add to.", backup); } } grammar.AddTerminal(name, mpge); } else { throw new InfinityGrammarScriptParseError("MultiGrammarElement requires assignment after the name, missing '=' sign", backup); } } else { throw new InfinityGrammarScriptParseError("Check name", backup); } } else { throw new InfinityGrammarScriptParseError("Undetected error", backup); } }
protected static void ParseGrammarElement(ref Grammar.Grammar grammar, string line) { string backup = line; LiteralGrammarElement SymbolKeyword = new LiteralGrammarElement("GrammarElement "); if (SymbolKeyword.Validate(ref line, true).Result) { line = line.Trim(); string templine = line; SymbolSet AlphabetWithSpace = SymbolSet.FromType(SymbolSetPredefinedType.AlphaNumeric); AlphabetWithSpace.Add(new Symbol('_')); AlphabetWithSpace.Add(new Symbol('$')); AlphabetWithSpace.Add(new Symbol('/')); VariableLengthGrammarElement SymbolName = new VariableLengthGrammarElement(VariableLengthGrammarElementType.Plus, AlphabetWithSpace); if (SymbolName.Validate(ref line, true).Result) { string name = templine.Substring(0, templine.IndexOf(line)).Trim(); line = line.Trim(); LiteralGrammarElement EqualsSign = new LiteralGrammarElement("="); if (EqualsSign.Validate(ref line, true).Result) { line = line.Trim(); if (line.Contains(" or ") || line.Contains(" | ") || (line.Contains("precedence") && (line.Contains("Ascending") || line.Contains("Descending")))) { MultiParsePrecedenceType precedence = MultiParsePrecedenceType.Normal; if (line.IndexOf(',') >= 0) { string precedenceString = line.Substring(line.IndexOf(',') + 1).Trim(); line = line.Substring(0, line.IndexOf(',')).Trim(); LiteralGrammarElement precKey = new LiteralGrammarElement("precedence"); LiteralGrammarElement colon = new LiteralGrammarElement(":"); if (precKey.Validate(ref precedenceString, true).Result) { precedenceString = precedenceString.Trim(); if (colon.Validate(ref precedenceString, true).Result) { string[] precedenceList = Enum.GetNames(typeof(MultiParsePrecedenceType)); LiteralGrammarElement type = new LiteralGrammarElement(precedenceList); precedenceString = precedenceString.Trim(); if (type.Validate(ref precedenceString, false).Result) { precedence = (MultiParsePrecedenceType)Enum.Parse(typeof(MultiParsePrecedenceType), precedenceString); } } } } string[] terminals = line.Split(new string[] { " or ", " | " }, StringSplitOptions.RemoveEmptyEntries); MultiParseGrammarElement mpge = new MultiParseGrammarElement(); mpge.Precedence = precedence; int count = 0; foreach (string ss in terminals) { try { GrammarElement cge = ParseCGE(grammar, ss); if (cge.Name == null || cge.Name == "") { cge.Name = name + ":" + count++; } mpge.AddTerminal(cge); } catch (KeyNotFoundException k) { _temp.Add(backup); throw new InfinityGrammarScriptParseError("No such terminal to add to. " + k.Message, backup); } } grammar.AddTerminal(name, mpge); } else { string delimiters = " \n\r\t"; int idx = line.LastIndexOf(','); if (line.Substring(idx + 1).Trim().StartsWith("delimiters")) { delimiters = line.Substring(idx + 1).Trim(); line = line.Substring(0, idx); LiteralGrammarElement lge = new LiteralGrammarElement("delimiters"); if (lge.Validate(ref delimiters, true).Result) { delimiters = delimiters.Trim(); if (delimiters.StartsWith("[") && delimiters.EndsWith("]")) { delimiters = delimiters.Substring(1, delimiters.Length - 2); if (delimiters.Length == 0) { delimiters = "@None"; } } } else { throw new InfinityGrammarScriptParseError("Delimiters not declared properly - " + delimiters, backup); } } try { GrammarElement cge = ParseCGE(grammar, line, delimiters); grammar.AddTerminal(name, cge); } catch (KeyNotFoundException) { _temp.Add(backup); throw new InfinityGrammarScriptParseError("No such terminal to add to.", backup); } } } } } }
protected static void ParseSymbolSet(ref Grammar.Grammar grammar, string line) { string backup = line; LiteralGrammarElement SymbolKeyword = new LiteralGrammarElement("SymbolSet ") { Name = "SymbolSetKeyword" }; if (SymbolKeyword.Validate(ref line, true).Result) { line = line.Trim(); string exception = ""; if (line.Contains("except")) { int idxx = line.IndexOf("except"); exception = line.Substring(idxx + 7).Trim(); line = line.Substring(0, idxx); } string templine = line; SymbolSet Identifier = SymbolSet.FromType(SymbolSetPredefinedType.AlphaNumeric); Identifier.Add(new Symbol('_')); Identifier.Add(new Symbol('$')); VariableLengthGrammarElement SymbolName = new VariableLengthGrammarElement(VariableLengthGrammarElementType.Plus, Identifier) { Name = "Identifier" }; if (SymbolName.Validate(ref line, true).Result) { string name = templine.Substring(0, templine.IndexOf(line)).Trim(); line = line.Trim(); LiteralGrammarElement EqualsSign = new LiteralGrammarElement("=") { Name = "EqualsSign" }; if (EqualsSign.Validate(ref line, true).Result) { line = line.Trim(); #region Symbol Set %[...] if (line.StartsWith("%")) { line = line.Substring(1); line = line.Trim(); if (line.StartsWith("[") && line.EndsWith("]")) { line = line.Substring(1, line.Length - 2); SymbolSet set = new SymbolSet(); foreach (char c in line) { set.Add(new Symbol(c)); } foreach (char c in exception) { set.RemoveSymbol(new Symbol(c)); } grammar.AddSymbolSet(name, set); LiteralGrammarElement none = new LiteralGrammarElement(); none.AddElement(set); VariableLengthGrammarElement star = new VariableLengthGrammarElement(VariableLengthGrammarElementType.Star, set); VariableLengthGrammarElement plus = new VariableLengthGrammarElement(VariableLengthGrammarElementType.Plus, set); grammar.AddTerminal(name, none); grammar.AddTerminal(name + "*", star); grammar.AddTerminal(name + "+", plus); } } #endregion #region Symbol Set [...] else if (line.StartsWith("[") && line.EndsWith("]")) { line = line.Substring(1, line.Length - 2); SymbolSet set = GetSetValues(line); foreach (char c in exception) { set.RemoveSymbol(new Symbol(c)); } grammar.AddSymbolSet(name, set); LiteralGrammarElement none = new LiteralGrammarElement(); none.AddElement(set); VariableLengthGrammarElement star = new VariableLengthGrammarElement(VariableLengthGrammarElementType.Star, set); VariableLengthGrammarElement plus = new VariableLengthGrammarElement(VariableLengthGrammarElementType.Plus, set); grammar.AddTerminal(name, none); grammar.AddTerminal(name + "*", star); grammar.AddTerminal(name + "+", plus); } #endregion #region Symbol Set with Predefined/Predeclared Sets else { string[] types = Enum.GetNames(typeof(SymbolSetPredefinedType)); LiteralGrammarElement NewKeyword = new LiteralGrammarElement("new"); LiteralGrammarElement SetTypes = new LiteralGrammarElement(types); CompoundGrammarElement PreDefinedSet = new CompoundGrammarElement(NewKeyword, SetTypes) { Delimiters = " \n\r" }; string[] values = line.Split(','); SymbolSet set = new SymbolSet(); foreach (string valueq in values) { string value = valueq.Trim(); string iv = value; string iv2 = value; if (PreDefinedSet.Validate(ref iv2, true).Result) { NewKeyword.Validate(ref value, true); SymbolSetPredefinedType type = (SymbolSetPredefinedType)Enum.Parse(typeof(SymbolSetPredefinedType), value); SymbolSet temp = SymbolSet.FromType(type); foreach (Symbol s in temp) { set.Add(s); } } else if (SymbolName.Validate(ref iv, true).Result) { if (grammar.Symbols.Keys.Contains(value)) { set.Add(grammar.Symbols[value]); } else if (grammar.SymbolSets.Keys.Contains(value)) { foreach (Symbol sym in grammar.SymbolSets[value]) { set.Add(sym); } } else { throw new InfinityGrammarScriptParseError("Symbol not declared or found - " + value, backup); } } else { throw new InfinityGrammarScriptParseError("Invalid parameters passed - " + value, backup); } } foreach (char c in exception) { set.RemoveSymbol(new Symbol(c)); } grammar.SymbolSets.Add(name, set); LiteralGrammarElement none = new LiteralGrammarElement(); none.AddElement(set); VariableLengthGrammarElement star = new VariableLengthGrammarElement(VariableLengthGrammarElementType.Star, set); VariableLengthGrammarElement plus = new VariableLengthGrammarElement(VariableLengthGrammarElementType.Plus, set); grammar.AddTerminal(name, none); grammar.AddTerminal(name + "*", star); grammar.AddTerminal(name + "+", plus); } #endregion } else { throw new InfinityGrammarScriptParseError("Syntax requires a symbol value assignment, which is missing.", backup); } } else { throw new InfinityGrammarScriptParseError("The Symbol name specified was not valid. Names given can have Letters, Numbers and $ and _.", backup); } } else { throw new InfinityGrammarScriptParseError("Not a SymbolSet definition.", backup); } }
protected static void ParseSymbolRange(ref Grammar.Grammar grammar, string line) { string backup = line; LiteralGrammarElement SymbolRangeKeyword = new LiteralGrammarElement("SymbolRange "); if (SymbolRangeKeyword.Validate(ref line, true).Result) { line = line.Trim(); string templine = line; SymbolSet AlphabetWithSpace = SymbolSet.FromType(SymbolSetPredefinedType.AlphaNumeric); AlphabetWithSpace.Add(new Symbol('_')); AlphabetWithSpace.Add(new Symbol('$')); VariableLengthGrammarElement SymbolName = new VariableLengthGrammarElement(VariableLengthGrammarElementType.Plus, AlphabetWithSpace); if (SymbolName.Validate(ref line, true).Result) { string name = templine.Substring(0, templine.IndexOf(line)).Trim(); line = line.Trim(); LiteralGrammarElement EqualsSign = new LiteralGrammarElement("="); if (EqualsSign.Validate(ref line, true).Result) { line = line.Trim(); string templine2 = line; LiteralGrammarElement FromKeyword = new LiteralGrammarElement("From "); LiteralGrammarElement FromStrKeyword = new LiteralGrammarElement("FromStr "); if (FromKeyword.Validate(ref line, true).Result) { line = line.Trim(); string from = line.Substring(0, line.IndexOf("To") - 1).Trim(); string to = line.Substring(line.IndexOf("To") + 2, line.Length - line.IndexOf("To") - 2).Trim(); from = GetSymbolValue(from); to = GetSymbolValue(to); Console.WriteLine(from + " to " + to); SymbolRange sr = new SymbolRange(from, to); grammar.AddSymbol(name, sr); } else if (FromStrKeyword.Validate(ref line, true).Result) { line = line.Trim(); string from = line.Substring(0, line.IndexOf("To") - 1).Trim(); string to = line.Substring(line.IndexOf("To") + 2, line.Length - line.IndexOf("To") - 2).Trim(); from = GetSymbolValue(from); to = GetSymbolValue(to); Console.WriteLine(from + " to " + to); SymbolRange sr = new SymbolRange(from, to); grammar.AddSymbol(name, sr); } else { throw new InfinityGrammarScriptParseError("From ranges specified by wrong keyword or syntax error.", backup); } } else { throw new InfinityGrammarScriptParseError("Syntax requires a symbol value assignment, which is missing.", backup); } } else { throw new InfinityGrammarScriptParseError("The Symbol name specified was not valid. Names given can have Letters, Numbers and $ and _.", backup); } } else { throw new InfinityGrammarScriptParseError("Not a valid SymbolRange definition.", backup); } }