public void variable()
{
var a = new Analyser();
var node = a.Analyse(new StringTokenizer("a-7 ? 1+b : (-c+1 ? -8*a : -24 )"));
Assert.That(node.ToString(), Is.EqualTo("((a - 7) ? (1 + b) : ((-(c) + 1) ? (-(8) * a) : -(24)))"));
}
public void NoErrorsWhenLogErrorsIsFalse()
{
Analyser.Analyse(_validAST);
var errors = Analyser.GetErrors();
Assert.AreEqual(0, errors.Count);
}
public void if_at_work()
{
var a = new Analyser();
var node = a.Analyse(new StringTokenizer("3-7 ? 1+8 : (-4+1 ? -8 : -24 )"));
Assert.That(node.ToString(), Is.EqualTo("((3 - 7) ? (1 + 8) : ((-(4) + 1) ? -(8) : -(24)))"));
}
public void ErrorForInvalidAST()
{
Analyser.Analyse(_invalidAST);
var errors = Analyser.GetErrors();
Assert.AreEqual(1, errors.Count);
}
public void MultipleFormNodesInAST()
{
Analyser.Analyse(_invalidAST);
var errors = Analyser.GetErrors();
Assert.AreEqual("ERROR This AST contains multiple 'FormNode'.", errors[0]);
}
public void NoErrorsForValidAST()
{
Analyser.Analyse(_validAST);
var errors = Analyser.GetErrors();
Assert.AreEqual(0, errors.Count);
}
public static (HashSet <Error> diagnostics, string jsCode) Compile(string jurCode)
{
var diagnostics = new HashSet <Error>();
var tree = Parser.ParseString(diagnostics, jurCode);
if (tree == null)
{
return(diagnostics, string.Empty);
}
var knowledge = Analyser.Analyse(diagnostics, tree);
if (diagnostics.Any())
{
return(diagnostics, string.Empty);
}
var jsCode = new Generator(knowledge, tree).GenerateJs();
if (diagnostics.Any())
{
throw new Exception($"code generation found errors:\n{diagnostics.Select(x => x.ToString()).Glue()}");
}
return(diagnostics, jsCode);
}
private void CmdAnalyse_Click()
{
var sb = new StringBuilder();
sb.AppendLine($"Analysing ...");
var sw = Stopwatch.StartNew();
var sql = TxtInput;
var analyser = new Analyser(sql);
analyser.Analyse();
var allNodes = analyser.AllNodes;
var leafNodes = analyser.LeafNodes;
foreach (var node in leafNodes)
{
var nodeDepth = node.GetDepth();
var padding = new string(' ', nodeDepth);
sb.AppendLine($"{padding} [{nodeDepth}@{node.GetType().Name}] {node} ${analyser.GetWeightedCost(node):0}");
}
sb.AppendLine($"Analysed in {sw.ElapsedMilliseconds} ms");
sb.AppendLine($" MaxDepth = {analyser.MaxDepth}");
sb.AppendLine($" Height = {allNodes.Count()}");
sb.AppendLine($" Leaves = {leafNodes.Count()}");
sb.AppendLine($" TotalDepth = {analyser.TotalDepth}");
sb.AppendLine($" TotalWeightedCost = ${analyser.TotalWeightedCost:0}");
TxtOutput = sb.ToString();
}
public void RandomCharsTest()
{
FormNode randomCharForm = QLParserHelper.Parse(FormExamples.RandomChars);
var isValid = Analyser.Analyse(randomCharForm);
Assert.IsFalse(isValid);
}
public void MultibleVariablesBindingTest()
{
const string Code =
@"
Var x = 1; ... decl1
Var y = x; ... decl2
";
Compilation tree = Analyser.Analyse(Code);
Assert.NotNull(tree);
var decl1 = tree !.Program.TopLevelStatementNodes[0] as VariableDeclarationStatementNode;
var decl2 = tree !.Program.TopLevelStatementNodes[1] as VariableDeclarationStatementNode;
Assert.NotNull(decl1);
Assert.NotNull(decl2);
var varX = decl1 !.VariableIdentifierNode as BoundIdentifierNode;
var varY = decl2 !.VariableIdentifierNode as BoundIdentifierNode;
Assert.NotNull(varX);
Assert.NotNull(varY);
var idX = decl2.AssignedExpressionNode as IdentifierExpressionNode;
Assert.NotNull(idX);
var boundIdX = idX !.IdentifierNode as BoundIdentifierNode;
Assert.IsTrue(ReferenceEquals(varX !.Symbol, boundIdX !.Symbol));
}
private void btnAnalyse_Click(object sender, RoutedEventArgs e)
{
lstAnalyse.Items.Clear();
if (analyser == null)
{
MessageBox.Show("未成功生成文法分析");
return;
}
var v = txtInput.Text;
var output = new List <string>();
var success = analyser.Analyse(v, output);
foreach (var s in output.Take(output.Count - 1))
{
lstAnalyse.Items.Add(new ListViewItem()
{
Content = s
});
}
MessageBox.Show(output.Last());
}
public static void Main(string[] args)
{
if (args.Length != 1)
{
Usage();
return;
}
Console.WriteLine($"Analysing [{args[0]}] ...");
var sw = Stopwatch.StartNew();
var sql = File.ReadAllText(args[0]);
var analyser = new Analyser(sql);
analyser.Analyse();
var allNodes = analyser.AllNodes;
var leafNodes = analyser.LeafNodes;
foreach (var node in leafNodes)
{
var nodeDepth = node.GetDepth();
var padding = new string(' ', nodeDepth);
Console.WriteLine($"{padding} [{nodeDepth}@{node.GetType().Name}] {node} ${analyser.GetWeightedCost(node):0}");
}
Console.WriteLine($"Analysed [{args[0]}] in {sw.ElapsedMilliseconds} ms");
Console.WriteLine($" MaxDepth = {analyser.MaxDepth}");
Console.WriteLine($" Height = {allNodes.Count()}");
Console.WriteLine($" Leaves = {leafNodes.Count()}");
Console.WriteLine($" TotalDepth = {analyser.TotalDepth}");
Console.WriteLine($" TotalWeightedCost = ${analyser.TotalWeightedCost:0}");
}
public void SimpleBindingTest()
{
const string Code =
@"
Var x = 1;
x = 2;
";
Compilation tree = Analyser.Analyse(Code);
Assert.NotNull(tree);
Assert.IsInstanceOf <VariableDeclarationStatementNode>(tree !.Program.TopLevelStatementNodes[0]);
Assert.IsInstanceOf <VariableAssignmentStatementNode>(tree.Program.TopLevelStatementNodes[1]);
var decl = (VariableDeclarationStatementNode)tree !.Program.TopLevelStatementNodes[0];
var assg = (VariableAssignmentStatementNode)tree !.Program.TopLevelStatementNodes[1];
Assert.IsInstanceOf <BoundIdentifierNode>(decl.VariableIdentifierNode);
Assert.IsInstanceOf <BoundIdentifierNode>(assg.VariableIdentifierNode);
var var1 = ((BoundIdentifierNode)decl.VariableIdentifierNode).Symbol;
var var2 = ((BoundIdentifierNode)assg.VariableIdentifierNode).Symbol;
Assert.IsTrue(ReferenceEquals(var1, var2));
}
static void Main(string[] args)
{
Console.WriteLine("---- Start parsing the QL ----");
FormNode ql = QLParserHelper.Parse(Util.FileToString(QLFile));
QLPrinter.Print(ql);
Console.WriteLine();
Console.WriteLine("---- Start parsing QLS ----");
QLSNode qls = QLSParserHelper.Parse(Util.FileToString(QLSFile));
QLSPrinter.Print(qls);
Analyser.Analyse(ql, qls);
var errors = Analyser.GetErrors();
Console.WriteLine("\n\n---- Errors and/or warnings: {0} ----", errors.Count);
foreach (string error in errors)
{
Console.WriteLine(error);
}
Console.ReadLine();
}
public void FrameworkFuncBindingTest()
{
const string Code =
@"
Output(""4"");
";
Compilation tree = Analyser.Analyse(Code);
Assert.NotNull(tree);
Assert.AreEqual(1, tree !.Program.TopLevelStatementNodes.Count);
Assert.IsInstanceOf <FunctionCallStatementNode>(tree.Program.TopLevelStatementNodes[0]);
var fcsn = (FunctionCallStatementNode)tree.Program.TopLevelStatementNodes[0];
Assert.IsInstanceOf <IdentifierExpressionNode>(fcsn.FunctionExpressionNode);
var idex = (IdentifierExpressionNode)fcsn.FunctionExpressionNode;
Assert.IsInstanceOf <BoundIdentifierNode>(idex.IdentifierNode);
var bdid = (BoundIdentifierNode)idex.IdentifierNode;
Assert.IsInstanceOf <FrameworkFunctionSymbolNode>(bdid.Symbol);
var func = (FrameworkFunctionSymbolNode)bdid.Symbol;
Assert.AreEqual("Output", func.Identifier);
}
protected override void Visit(MethodDefinition method)
{
if (method.HasBody)
{
var body = method.Body;
var il = body.GetILProcessor();
il.Body.SimplifyMacros();
Analysis = null;
Instruction instruction = body.Instructions[0];
while (instruction != null)
{
if (ShouldVisit(instruction))
{
if (Analysis == null)
{
Analysis = Analyser.Analyse(method);
}
instruction = Visit(il, instruction);
}
else
{
instruction = instruction.Next;
}
}
il.Body.OptimizeMacros();
}
}
public void with_variables()
{
var a = new Analyser();
var node = a.Analyse(new StringTokenizer("12*-X+9"));
Assert.That(node.ToString(), Is.EqualTo("((12 * -(X)) + 9)"));
}
public void factors_with_minus()
{
var a = new Analyser();
var node = a.Analyse(new StringTokenizer("8-12*12+5"));
Assert.That(node.ToString(), Is.EqualTo("((8 - (12 * 12)) + 5)"));
}
public void addition_and_factors()
{
var a = new Analyser();
var node = a.Analyse(new StringTokenizer("8*12+12"));
Assert.That(node.ToString(), Is.EqualTo("((8 * 12) + 12)"));
}
public void simple_factors()
{
var a = new Analyser();
var node = a.Analyse(new StringTokenizer("8*12/5*12"));
Assert.That(node.ToString(), Is.EqualTo("(((8 * 12) / 5) * 12)"));
}
public void factors_with_addition()
{
var a = new Analyser();
var node = a.Analyse(new StringTokenizer("8+12*12"));
Assert.That(node.ToString(), Is.EqualTo("(8 + (12 * 12))"));
}
static void Main(string[] args)
{
string[] lines = System.IO.File.ReadAllLines(@"..\..\..\QLParserTester\Questionnaire.gl");
StringBuilder builder = new StringBuilder();
foreach (string line in lines)
{
builder.AppendLine(line);
}
Console.WriteLine("Start parsing the QL");
FormNode form = QLParserHelper.Parse(builder.ToString());
PrintForm(form);
Analyser.Analyse(form);
var errors = Analyser.GetErrors();
Console.WriteLine("\n\n---- Errors: {0} ----", errors.Count);
foreach (string error in errors)
{
Console.WriteLine(error);
}
Console.ReadLine();
}
public void FrameworkTypeBindingTest()
{
const string Code =
@"
Var x As String;
";
Compilation tree = Analyser.Analyse(Code);
Assert.NotNull(tree);
Assert.AreEqual(1, tree !.Program.TopLevelStatementNodes.Count);
Assert.IsInstanceOf <VariableDeclarationStatementNode>(tree.Program.TopLevelStatementNodes[0]);
var vdecl = (VariableDeclarationStatementNode)tree.Program.TopLevelStatementNodes[0];
Assert.AreEqual("x", vdecl.VariableIdentifier);
Assert.IsInstanceOf <IdentifierTypeSpecNode>(vdecl.TypeSpecNode);
var idtype = (IdentifierTypeSpecNode)vdecl.TypeSpecNode !;
Assert.IsInstanceOf <BoundIdentifierNode>(idtype.IdentifierNode);
var bdid = (BoundIdentifierNode)idtype.IdentifierNode;
Assert.IsInstanceOf <FrameworkTypeSymbolNode>(bdid.Symbol);
var bitsn = (FrameworkTypeSymbolNode)bdid.Symbol;
Assert.AreEqual(FrameworkType.String, bitsn.FrameworkType);
}
public void unary_minus_at_work()
{
var a = new Analyser();
var node = a.Analyse(new StringTokenizer("12*-7"));
Assert.That(node.ToString(), Is.EqualTo("(12 * -(7))"));
}
public static ErrorEventArgs Error(string code)
{
return(Error(() =>
{
Compilation compilation = Analyser.Analyse(code);
Assert.IsNull(compilation);
}));
}
public static Compilation NoError(string code)
{
return(NoError(() =>
{
Compilation compilation = Analyser.Analyse(code);
Assert.NotNull(compilation);
return compilation !;
}));
}
public async Task <HttpResponseMessage> Post(string output = "json")
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
Directory.CreateDirectory("Uploads");
var provider = new MultipartFormDataStreamProvider("Uploads");
try
{
await Request.Content.ReadAsMultipartAsync(provider);
var config = ConsoleAnalyserConfig.FromFile("config.json");
var analyser = new Analyser(config);
foreach (var file in provider.FileData)
{
analyser.AddFile(file.LocalFileName);
}
var results = analyser.Analyse();
foreach (var file in provider.FileData)
{
var search = System.IO.Path.GetFileName(file.LocalFileName);
foreach (var analysedResult in results)
{
if (analysedResult.Source.Name.Contains(search))
{
analysedResult.Source.Name = file.Headers.ContentDisposition.FileName;
}
}
try
{
System.IO.File.Delete(file.LocalFileName);
}
catch { }
}
if (output != "html")
{
return(Request.CreateResponse(HttpStatusCode.OK, results));
}
var reporter = new HtmlReporter(results);
var html = reporter.Generate();
return(Request.CreateResponse(HttpStatusCode.OK, html));
}
catch (System.Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
}
public void LegalVariableDeclarationAndAssignmentTest()
{
const string Code = @"
Var x As Int = 4;
";
Compilation tree = Analyser.Analyse(Code);
Assert.NotNull(tree);
}
public async Task <Compilation?> GetCompilationAsync()
{
if (compilation == null)
{
string code = await File.ReadAllTextAsync(kryptonFileLocation);
compilation = await Task.Run(() => Analyser.Analyse(code));
}
return(compilation);
}
public IEnumerable <Result> AnalyserResults(string text, bool isUrl, bool inPage, bool inMeta, bool external)
{
Analyser seoAnalyser = new Analyser(text)
{
IsUrl = isUrl,
OccurencesInPage = inPage,
OccurencesInMetaTag = inMeta,
ExternalLinks = external
};
return(seoAnalyser.Analyse());
}
