public static List <CFG> Analyze(Node n)
{
var symbols = new SymbolTable();
var scope = new Scope
{
ScopeType = ScopeType.Program,
SymbolTable = symbols
};
symbols.AddSymbol(new BuiltinFunctionVariable
{
Name = "$main$",
Scope = scope
});
symbols.AddSymbol(new BuiltinFunctionVariable
{
Name = "writeln",
Scope = scope
});
symbols.AddSymbol(new BuiltinFunctionVariable
{
Name = "read",
Scope = scope
});
symbols.AddSymbol(new BuiltinVariable
{
Name = "true",
PrimitiveType = PrimitiveType.Boolean,
SubType = PrimitiveType.Void,
Scope = scope
});
symbols.AddSymbol(new BuiltinVariable
{
Name = "false",
PrimitiveType = PrimitiveType.Boolean,
SubType = PrimitiveType.Void,
Scope = scope
});
var visitors = new Visitor[]
{
new ScopeVisitor(scope),
new BuiltinVisitor(scope),
new TypeVisitor(scope),
new ExpressionVisitor(scope),
};
foreach (var v in visitors)
{
n.Accept(v);
}
var cfgVisitor = new CfgVisitor(scope, new List <CFG>());
var cfg = n.Accept(cfgVisitor);
Console.WriteLine(string.Join("\n", cfg));
return(cfg);
}
public override string GenerateCode(AbstractNode node, string indentation)
{
StringBuilder errorBuilder = new StringBuilder();
ConverterSettings settings = new ConverterSettings("codegeneration.cs");
string output = null;
Node booNode = (Node)node.AcceptVisitor(new ConvertVisitor(settings), null);
if (settings.Errors.Count > 0)
{
foreach (CompilerError error in settings.Errors)
{
errorBuilder.AppendLine(error.ToString());
}
}
else
{
if (settings.Warnings.Count > 0)
{
foreach (CompilerWarning warning in settings.Warnings)
{
errorBuilder.AppendLine(warning.ToString());
}
}
booNode.Accept(new RemoveRedundantTypeReferencesVisitor());
using (StringWriter w = new StringWriter()) {
BooPrinterVisitor printer = new BooPrinterVisitor(w);
int indentCount = 0;
foreach (char c in indentation)
{
if (c == '\t')
{
indentCount += 4;
}
else
{
indentCount += 1;
}
}
indentCount /= 4;
while (indentCount-- > 0)
{
printer.Indent();
}
booNode.Accept(printer);
output = w.ToString();
}
}
if (errorBuilder.Length > 0)
{
MessageService.ShowMessage(errorBuilder.ToString());
}
return(output);
}
public Node Visit(Node node)
{
TextNode tn = node as TextNode;
if (tn != null)
{
_textContent.Append(tn.Value);
_nodeContent.Add(tn);
return(node);
}
Number number = node as Number;
if (number != null)
{
_nodeContent.Add(number);
return(node);
}
Keyword keyword = node as Keyword;
if (keyword != null)
{
_nodeContent.Add(keyword);
_textContent.Append(keyword.Value);
return(node);
}
node.Accept(this);
return(node);
}
public void ParseSimpleStylesheetWithTwoPagesAndSections_WillSucceed()
{
var stylesheetTask = new StylesheetTask(TestDataResolver.LoadTestFile("emptyStylesheetWithTwoPagesAndSections.qls"), new SymbolTable());
Node ast = _parsingService.Process(stylesheetTask).Ast;
_assertVisitor.EnqueueStylesheetNodeCallback(st =>
{
Assert.AreEqual("test", st.Label);
});
_assertVisitor.EnqueuePageNodeCallback(p =>
{
Assert.AreEqual("testPage", p.Label);
});
_assertVisitor.EnqueuePageNodeCallback(p =>
{
Assert.AreEqual("nextPage", p.Label);
});
_assertVisitor.EnqueueSectionNodeCallback(s =>
{
Assert.AreEqual("testSection", s.Label);
});
_assertVisitor.EnqueueSectionNodeCallback(s =>
{
Assert.AreEqual("nextSection", s.Label);
});
ast.Accept(_assertVisitor);
_assertVisitor.VerifyAll();
}
public static void Run()
{
var tree = new Node <int>(new Node <int>(new Leaf <int>(1), 2, new Leaf <int>(3)),
4, new Node <int>(new Leaf <int>(5), 6, new Leaf <int>(7)));
var sum = tree.Accept(new AlgebraSumVisitor());
}
public static System.Object GetValue(Node n)
{
NodeVisitor visitor = new NodeVisitor();
n.Accept(visitor);
return(visitor.value);
}
public static string SuffixValue(this Node suffix, Interpreter interpreter)
{
var prop = suffix as PropertyReferenceSuffix;
return(prop != null
? prop.Identifier.Value
: CheckIndex(suffix.Accept(interpreter), interpreter));
}
public override T traverse(Node n)
{
if (n == null)
{
return(default(T));
}
return
(n.Accept <T>(Processor));
}
public Node Visit(Node node)
{
bool visitDeeper;
node = Execute(node, out visitDeeper);
if (visitDeeper && node != null)
node.Accept(this);
return node;
}
public virtual TResult VisitNode(Node node)
{
if (node != null)
{
return(node.Accept(this));
}
return(default(TResult));
}
public static void AssertCSharpCode(string expected, Node node)
{
var output = new StringWriter();
node.Accept(new CSharpPrinter(output));
StringsModule.AssertAreEqualIgnoringNewLineDifferences(
StringsModule.NormalizeIndentation(expected),
output.ToString().TrimEnd());
}
public static void Run(Node node, Visitor visitor)
{
node.Accept(visitor);
foreach (Node child in node.Children)
{
Run(child, visitor);
}
}
public static void AssertCSharpCode(string expected, Node node)
{
var output = new StringWriter();
node.Accept(new CSharpPrinter(output));
StringsModule.AssertAreEqualIgnoringNewLineDifferences(
StringsModule.NormalizeIndentation(expected),
output.ToString().TrimEnd());
}
public Response <T> Request <T>(T command) where T : ICommand
{
try
{
return(_node.Accept(command));
}
catch (Exception e)
{
return(new ErrorResponse <T>("Unable to send command to node.", command));
}
}
public void ParseSimpleStylesheetWithOnePageOneSectionOneQuestionAndWidget_WillSucceed()
{
var stylesheetTask = new StylesheetTask(TestDataResolver.LoadTestFile("onePageStylesheetWithQuestionAndWidget.qls"), new SymbolTable());
Node ast = _parsingService.Process(stylesheetTask).Ast;
_assertVisitor.EnqueueWidgetNodeCallback(w =>
{
Assert.AreEqual("Radio", w.Widget.ToString());
});
ast.Accept(_assertVisitor);
_assertVisitor.VerifyAll();
}
/// <summary>
/// Initializes a new instance of the <see cref="Query"/> class.
/// </summary>
/// <param name="log">The log to query</param>
/// <param name="settings">The application settings</param>
/// <param name="query">The query string to execute</param>
internal Query(Log log, Node tree)
{
_log = log;
_tree = tree;
// define result columns for the query
var visitor = new FieldsVisitor();
_tree.Accept(visitor);
_columns = visitor.Fields;
if (visitor.GeneratesDynamicFields)
{
_dynamicColumns = new Dictionary <string, Type>();
}
// print the query tree for debugging
var format = new FormatVisitor();
_tree.Accept(format);
_logger.Info($"Created query tree\r\n" + format.ToString().TrimEnd());
}
public Node Visit(Node node)
{
bool visitDeeper;
node = Execute(node, out visitDeeper);
if (visitDeeper && node != null)
{
node.Accept(this);
}
return(node);
}
public void BuilderVisitorCantVisitNonRoot()
{
#region Arrange Bad Root Node Input and Builder Visitor
var root = new Node(NodeType.Service, "service");
var sut = new BuilderVisitor();
#endregion Arrange Bad Root Node Input and Builder Visitor
var expected = Assert.Throws<InvalidOperationException>(() => root.Accept(sut));
expected.Message.Should().Be("Cannot use BuilderVisitor on non-root Node");
}
protected override void VisitRecursive(Node node)
{
if (node == null)
{
Return("");
return;
}
_childStrings.Push(new List <string>());
foreach (Node child in node)
{
VisitRecursive(child);
}
node.Accept(this);
}
private static int replyExecutionTree(Node module,
string modname,
WSOutputSink sink)
{
Action <XmlDocument, XmlElement> handler = (doc, parent) =>
{
var mod = doc.CreateElement("module");
var vis = new ExecutionTreeJSONVisitor(doc, mod);
parent.AppendChild(module.Accept(vis));
};
sink.SendData("execution-tree", modname, handler);
return(0);
}
public override void Postprocess(Node root, List <Message> log)
{
if (root != null)
{
var visitor = new RoutineAggregationVisitor();
root.Accept(visitor);
Log.AddRange(visitor.Log);
}
foreach (var rec in Log)
{
rec.Source = this.GetType().FullName;
}
}
public void ParseSimpleStylesheetWithOnePage_WillSucceed()
{
Node ast = _parsingService.ParseQLSSheet(TestDataResolver.LoadTestFile("emptyStylesheetWithOnePage.qls"));
_assertVisitor.EnqueueStylesheetNodeCallback(st =>
{
Assert.AreEqual("test", st.Label);
});
_assertVisitor.EnqueuePageNodeCallback(p =>
{
Assert.AreEqual("testPage", p.Label);
});
ast.Accept(_assertVisitor);
_assertVisitor.VerifyAll();
}
private void addProperty(XmlElement parent,
string name, Node value)
{
var n = document.CreateElement(name);
if (value == null)
{
n.SetAttribute("type", "null");
parent.AppendChild(n);
return;
}
n.SetAttribute("type", "object");
existingNode = n;
parent.AppendChild(value.Accept(this));
}
protected void TreePostProcessing(Node root)
{
root.Accept(new RemoveAutoVisitor(GrammarObject));
root.Accept(new GhostListOptionProcessingVisitor(GrammarObject));
root.Accept(new LeafOptionProcessingVisitor(GrammarObject));
root.Accept(new MergeAnyVisitor(GrammarObject));
root.Accept(new MappingOptionsProcessingVisitor(GrammarObject));
NodeRetypingVisitor.Root = root;
root.Accept(NodeRetypingVisitor);
root = NodeRetypingVisitor.Root;
root.Accept(new UserifyVisitor(GrammarObject));
}
public override void Postprocess(Node root, List <Message> log)
{
if (Excluded.Count > 0)
{
var locations = log.Where(l => l.Location != null).Select(l => l.Location);
if (root != null)
{
var getLocationsVisitor = new GatherLocationsVisitor();
root.Accept(getLocationsVisitor);
locations = locations.Concat(getLocationsVisitor.Locations);
}
locations = locations.Distinct().OrderBy(l => l.Offset);
/// Сколько исключенных из компиляции символов было учтено на данный момент
var includedCharsCount = 0;
/// Сколько исключенных из компиляции строк было учтено на данный момент
var includedLinesCount = 0;
/// Сколько исключенных из компиляции участков было учтено на данный момент
var includedSegmentsCount = 0;
foreach (var loc in locations)
{
var start = loc.Offset + includedCharsCount;
/// Пока начало содержимого узла в текущих координатах лежит правее
/// начала первого не возвращённого в рассмотрение сегмента в координатах исходного файла,
/// поправляем текущие координаты с учётом добавления этого сегмента
while (includedSegmentsCount < Excluded.Count &&
Excluded[includedSegmentsCount].Start.Offset <= start)
{
includedCharsCount += Excluded[includedSegmentsCount].Length.Value;
includedLinesCount += Excluded[includedSegmentsCount].End.Line - Excluded[includedSegmentsCount].Start.Line + 1;
start += Excluded[includedSegmentsCount].Length.Value;
includedSegmentsCount += 1;
}
loc.Shift(includedLinesCount, 0, includedCharsCount);
}
}
}
public virtual bool LinkNodes(Dictionary <string, Node> nodeMap, Dictionary <string, string[]> linkMap)
{
foreach (string link in linkMap.Keys)
{
if (nodeMap.ContainsKey(link))
{
Node node = nodeMap[link];
foreach (string linkedlink in linkMap[link])
{
if (nodeMap.ContainsKey(linkedlink))
{
Node linkNode = nodeMap[linkedlink];
node.Accept(Visitor);
bool canNext = Visitor.CanAddNext(linkNode);
if (canNext)
{
node.AddNext(linkNode);
}
linkNode.Accept(Visitor);
bool canPrev = Visitor.CanAddPrevious(node);
if (canPrev)
{
linkNode.AddPrevious(node);
}
if (!canNext || !canPrev)
{
return(false);
}
}
else
{
return(false);
}
}
}
else
{
return(false);
}
}
return(true);
}
public void ParseSimpleStylesheetWithOnePageOneSectionOneQuestion_WillSucceed()
{
var stylesheetTask = new StylesheetTask(TestDataResolver.LoadTestFile("onePageStylesheetWithQuestion.qls"), new SymbolTable());
Node ast = _parsingService.Process(stylesheetTask).Ast;
_assertVisitor.EnqueueStylesheetNodeCallback(st =>
{
Assert.AreEqual("test", st.Label);
});
_assertVisitor.EnqueuePageNodeCallback(p =>
{
Assert.AreEqual("testPage", p.Label);
});
_assertVisitor.EnqueueQuestionNodeCallback(q =>
{
Assert.AreEqual("questionOne", q.Label);
});
ast.Accept(_assertVisitor);
_assertVisitor.VerifyAll();
}
public void ParseOptionWidgetWithCustomText_WillSucceed()
{
var stylesheetTask = new StylesheetTask(TestDataResolver.LoadTestFile("optionWidgetTest.qls"), new SymbolTable());
Node ast = _parsingService.Process(stylesheetTask).Ast;
_assertVisitor.EnqueueWidgetNodeCallback(w =>
{
Assert.AreEqual("Radio", w.Widget.ToString());
});
_assertVisitor.EnqueueWidgetOptionNodeCallback(o =>
{
Assert.AreEqual("Good", o.Label);
});
_assertVisitor.EnqueueWidgetOptionNodeCallback(o =>
{
Assert.AreEqual("Evil", o.Label);
});
ast.Accept(_assertVisitor);
_assertVisitor.VerifyAll();
}
public void Select <TNode>(Node <TNode> node) where TNode : class
{
_node = null;
node.Accept(this);
if (_node == null)
{
PropertyNode <T, TProperty> propertyNode = _configurator.Property <T, TProperty>(Property);
var parentNode = node as Node <T>;
if (parentNode == null)
{
throw new ArgumentException("Expected propertyNode, but was " + node.GetType().Name);
}
parentNode.AddActivation(propertyNode);
_node = propertyNode;
}
_next.Select(_node);
}
public void Select <TNode>(Node <TNode> node) where TNode : class
{
_node = null;
node.Accept(this);
if (_node == null)
{
AlphaNode <T> alphaNode = _configurator.Alpha <T>();
var parentNode = node as Node <T>;
if (parentNode == null)
{
throw new ArgumentException("Expected " + typeof(T).Tokens() + ", but was "
+ typeof(TNode).Tokens());
}
parentNode.AddActivation(alphaNode);
_node = alphaNode;
}
_next.Select(_node);
}
public void Select <TNode>(Node <TNode> node)
where TNode : class
{
_node = null;
node.Accept(this);
if (_node == null)
{
EachNode <T, TProperty, TElement> eachNode = CreateNode();
var parentNode = node as Node <Token <T, TProperty> >;
if (parentNode == null)
{
throw new ArgumentException("Expected " + typeof(T).Tokens() + ", but was "
+ typeof(TNode).Tokens());
}
parentNode.AddActivation(eachNode);
_node = eachNode;
}
_next.Select(_node);
}
public void Select <TNode>(Node <TNode> node)
where TNode : class
{
_node = null;
node.Accept(this);
if (_node == null)
{
EqualNode <T, TProperty> equalNode = _configurator.Equal <T, TProperty>();
var parentNode = node as Node <Token <T, TProperty> >;
if (parentNode == null)
{
throw new ArgumentException("Expected " + typeof(T).Tokens() + ", but was "
+ typeof(TNode).Tokens());
}
parentNode.AddActivation(equalNode);
_node = equalNode;
}
_next.Select(_node[_value]);
}
public void ParseStylesheetWithALocalStyleAndAllProperties_WillSucceed()
{
var stylesheetTask = new StylesheetTask(TestDataResolver.LoadTestFile("stylesheetWithOneQuestionAndLocalStyle.qls"), new SymbolTable());
Node ast = _parsingService.Process(stylesheetTask).Ast;
_assertVisitor.EnqueueQuestionNodeCallback(q =>
{
Assert.AreEqual("questionOne", q.Label);
});
_assertVisitor.EnqueuePropertyNodeCallback(p =>
{
Assert.AreEqual("width", p.Name);
Assert.AreEqual("400", p.Value);
});
_assertVisitor.EnqueuePropertyNodeCallback(p =>
{
Assert.AreEqual("font", p.Name);
Assert.AreEqual("Arial", p.Value);
});
_assertVisitor.EnqueuePropertyNodeCallback(p =>
{
Assert.AreEqual("fontsize", p.Name);
Assert.AreEqual("14", p.Value);
});
_assertVisitor.EnqueuePropertyNodeCallback(p =>
{
Assert.AreEqual("color", p.Name);
Assert.AreEqual("#999999", p.Value);
});
_assertVisitor.EnqueueWidgetNodeCallback(p =>
{
Assert.AreEqual("Spinbox", p.Widget.ToString());
});
ast.Accept(_assertVisitor);
_assertVisitor.VerifyAll();
}
protected override void VisitRecursive(Node node)
{
if (node == null) {
Return("");
return;
}
_childStrings.Push(new List<string>());
foreach (Node child in node) {
VisitRecursive(child);
}
node.Accept(this);
}
public void DebugVisitorShouldTrackDepth()
{
var root = new Node(NodeType.Root, "root");
var one = new Node(NodeType.Field, "one");
var two = new Node(NodeType.Type, "two");
var three = new Node(NodeType.Field, "three");
root.AddChild(one);
one.AddChild(two);
two.AddChild(three);
var debugVisitor = new DebugVisitor();
root.Accept(debugVisitor);
var depth = debugVisitor.GetDepth(three.Guid);
depth.Should().Be(3, "because root starts at 0 and we have a 3 deep tree");
}
public void Print(Node ast)
{
ast.Accept(this);
}
void StoreEntity(OpCode opcode, int index, Node value, IType elementType)
{
_il.Emit(OpCodes.Dup); // array reference
EmitLoadLiteral(index); // element index
bool stobj = IsStobj(opcode); // value type sequence?
if (stobj)
{
Type systemType = GetSystemType(elementType);
_il.Emit(OpCodes.Ldelema, systemType);
value.Accept(this);
EmitCastIfNeeded(elementType, PopType()); // might need to cast to decimal
_il.Emit(opcode, systemType);
}
else
{
value.Accept(this);
EmitCastIfNeeded(elementType, PopType());
_il.Emit(opcode);
}
}
public void Print(Node node)
{
node.Accept(this);
}
public void DebugVisitorShouldPrettyPrint()
{
var root = new Node(NodeType.Root, "root");
var one = new Node(NodeType.Field, "one");
var two = new Node(NodeType.Type, "two");
var three = new Node(NodeType.Field, "three");
root.AddChild(one);
one.AddChild(two);
two.AddChild(three);
var expected = "*Root : root" + Environment.NewLine +
"-Field : one" + Environment.NewLine +
"--Type : two" + Environment.NewLine +
"---Field : three" + Environment.NewLine;
var debugVisitor = new DebugVisitor();
root.Accept(debugVisitor);
var result = debugVisitor.ToString();
result.Should().Be(expected, "because pretty printing should be successful.");
}
protected virtual void VisitRecursive(Node node)
{
if (node == null) {
return;
}
if (VisitParentBeforeChildren) {
node.Accept(this);
}
for (int i = 0; i < node.ChildNodes.Count; i++) {
VisitRecursive(node.ChildNodes[i]);
}
if (!VisitParentBeforeChildren) {
node.Accept(this);
}
}
