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