public void RequiredSequenceTest(string data, int ruleNumber, bool shouldPass) { var parser = new LexicalParser <TokenType>(_Rules[ruleNumber]); ParserResult result = parser.Parse(data); result.Should().NotBeNull(); result.IsSuccess.Should().Be(shouldPass); }
public void LetNodeSingleFailTests(string data) { var parser = new LexicalParser <TokenType>(_onlyPlusRules); ParserResult result = parser.Parse(data); result.Should().NotBeNull(); result.IsSuccess.Should().BeFalse(); }
public void ForumlaTest(string data, bool shouldPass) { var parser = new LexicalParser <TokenType>(_forumalRules); ParserResult result = parser.Parse(data); result.Should().NotBeNull(); result.IsSuccess.Should().Be(shouldPass); }
public ExpressionLanguageAST Parser(string expression) { LexicalParser l = new LexicalParser(); l.SetParseContent(expression); SemanticParser s = new SemanticParser(); s.SetParseContent(l.Parse()); return s.Parse(); }
public void NoClassNameFailTest() { IEnumerable <string> data = new List <string> { "public class", "{", " public static string Cleanse(string name)", "}", }; var parser = new LexicalParser <TokenType>(_rules); ParserResult result = parser.Parse(string.Join(" ", data)); result.Should().NotBeNull(); result.IsSuccess.Should().BeFalse(); }
public JoinPointDefination(Position position, string advisorName, string pattern) { _position = position; _advisorName = advisorName; _pattern = pattern; LexicalParser lp = new LexicalParser(); lp.SetParseContent(_pattern); var tokens = lp.Parse(); try { Init(tokens); } catch (Exception ex) { ExceptionHelper.ThrowWeaveSyntaxInitialize(_pattern, ex); } }
public void NoStaticTest() { IEnumerable <string> data = new List <string> { "public class TestClass", "{", " public static string Cleanse(string name)", "}", }; var parser = new LexicalParser <TokenType>(_rules); ParserResult result = parser.Parse(string.Join(" ", data)); result.Should().NotBeNull(); result.IsSuccess.Should().BeTrue(); result.RootNode.OfType <Symbol <TokenType> >().Any(x => Language.SymStatic.Equals(x)).Should().BeFalse(); result.RootNode.OfType <Expression <TokenType> >().Single(x => Language.ClassName.Equals(x)).Value.Should().Be("TestClass"); result.RootNode.OfType <Expression <TokenType> >().Any(x => Language.SubclassName.Equals(x)).Should().BeFalse(); }
public void LetDifferentOpsValues(string data, string[] testValues) { var parser = new LexicalParser <TokenType>(_Rules); ParserResult result = parser.Parse(data); result.Should().NotBeNull(); result.IsSuccess.Should().BeTrue(); result.RootNode.OfType <Expression <TokenType> >().Single(x => Language.VariableName.Equals(x)).Value.Should().Be("MyVariable"); result.RootNode.OfType <Expression <TokenType> >().Single(x => Language.VariableType.Equals(x)).Value.Should().Be("double"); var values = result.RootNode.OfType <Expression <TokenType> >() .Where(x => Language.Variable.Equals(x)); values.Count().Should().Be(testValues.Length); values.Select(x => x.Value).OrderBy(x => x) .Zip(testValues.OrderBy(x => x), (o, i) => new { o, i }) .All(x => x.o == x.i) .Should().BeTrue(); }
static double ExecuteExpression(string expression, Dictionary <string, NumberType> variables, out IList <Token> lexics) { lexics = LexicalParser.Parse(expression).ToList(); SyntaxTree syntaxTree = SyntaxParser.Parse(lexics); DynamicMethod method = ArithmeticTreeCompiler.Compile(syntaxTree); var undefinedVariables = syntaxTree.VariableNames.Except(variables.Keys).ToList(); if (undefinedVariables.Count != 0) { throw new ArgumentException($"Undefined variables found: {string.Join(", ", undefinedVariables)}"); } object[] args = syntaxTree.VariableNames .OrderBy(i => i) .Select(i => variables[i]) .Cast <object>() .ToArray(); return((double)method.Invoke(null, args)); }
private QueryNode ParseData(IEnumerable <string> data, bool shouldPass) { string rawData = string.Join(" ", data); var parser = new LexicalParser <TokenType>(_rules); ParserResult result = parser.Parse(rawData); result.IsSuccess.Should().Be(shouldPass, result?.LastGood?.ToString() ?? "<no good last>"); if (!result.IsSuccess) { return(null); } // ==================================================================================== string rowsetName = result.RootNode .OfType <Expression <TokenType> >() .FirstOrDefault(x => Language.Rowset.Equals(x)) ?.Value; // ==================================================================================== IEnumerable <Rowset> rowsetList = result.RootNode .OfType <Expression <TokenType> >() .Where(x => Language.RefRowset.Equals(x) || Language.RefRowsetAlias.Equals(x)) .Partition((l, x) => !Language.RefRowsetAlias.Equals(x)) .Select(x => new Rowset(x)); // ==================================================================================== IEnumerable <ColumnName> columnList = result.RootNode .Where(x => Language.ColumnReference.Equals(x) || Language.SymAs.Equals(x) || Language.ColumnName.Equals(x)) .Partition((l, x) => Language.ColumnName.Equals(l.LastOrDefault())) .Select(x => new ColumnName(x)); IEnumerable <Join> joinList = result.RootNode .Where(x => Language.JoinReference.Equals(x)) .Partition(2) .Select(x => new Join(x)); return(new QueryNode(rowsetName, rowsetList, columnList, joinList)); }
public void LetNodeSingleVariableTest() { IEnumerable <string> data = new List <string> { "let EmptyLong long? = null;", }; var parser = new LexicalParser <TokenType>(_onlyPlusRules); ParserResult result = parser.Parse(string.Join(" ", data)); result.Should().NotBeNull(); result.IsSuccess.Should().BeTrue(); result.RootNode.OfType <Expression <TokenType> >().Single(x => Language.VariableName.Equals(x)).Value.Should().Be("EmptyLong"); result.RootNode.OfType <Expression <TokenType> >().Single(x => Language.VariableType.Equals(x)).Value.Should().Be("long?"); var values = result.RootNode.OfType <Expression <TokenType> >() .Where(x => Language.Variable.Equals(x)); values.Count().Should().Be(1); values.First().Value.Should().Be("null"); }
public void FullClassTest() { IEnumerable <string> data = new List <string> { "public static class NameCleaner", "{", " public static string Cleanse(string name)", " {", " Dictionary<string, string> changes = new Dictionary<string, string>();", "", " changes.Add(\" Twp\", \" Township\");", " changes.Add(\", Town of\", \"\");", " changes.Add(\" Town of\", \"\");", " changes.Add(\", Village of\", \"\");", "", " foreach (KeyValuePair<string, string> kvp in changes)", " {", " if (true == name.EndsWith(kvp.Key))", " {", " name = name.Substring(0, name.Length - kvp.Key.Length) + kvp.Value;", " }", " }", "", " return name;", " }", "}", }; var parser = new LexicalParser <TokenType>(_rules); ParserResult result = parser.Parse(string.Join(" ", data)); result.Should().NotBeNull(); result.IsSuccess.Should().BeTrue(); result.RootNode.OfType <Symbol <TokenType> >().Any(x => Language.SymStatic.Equals(x)).Should().BeTrue(); result.RootNode.OfType <Expression <TokenType> >().Single(x => Language.ClassName.Equals(x)).Value.Should().Be("NameCleaner"); result.RootNode.OfType <Expression <TokenType> >().Any(x => Language.SubclassName.Equals(x)).Should().BeFalse(); }
public TemplateAST Parse(string path) { string templateFile = Path.Combine(_engine.Path, path); _log.Debug("Begin parse template file [{0}].", templateFile); if (!File.Exists(templateFile)) ExceptionHelper.ThrowFileNotFound(templateFile); using (StreamReader r = new StreamReader(templateFile)) { string template = r.ReadToEnd(); LexicalParser lp = new LexicalParser(); lp.SetParseContent(template); SemanticParser sp = new SemanticParser(); sp.SetParseContent(lp.Parse()); TemplateAST ast = sp.Parse(); _log.Debug("Parse template file [{0}] success.", templateFile); ParseIncludeTemplate(ast); return ast; } }
public string RenderRaw(string textTemplate) { textTemplate.ThrowIfNullArgument(nameof(textTemplate)); try { LexicalParser lp = new LexicalParser(); lp.SetParseContent(textTemplate); SemanticParser sp = new SemanticParser(); sp.SetParseContent(lp.Parse()); TemplateAST ast = sp.Parse(); return this.Render(ast); } catch (ELParseException) { throw; } catch (EvalException) { throw; } catch (TemplateParseException) { throw; } catch (TemplateRenderException) { throw; } catch (Exception ex) { ExceptionHelper.ThrowWrapped(ex); return string.Empty; } }