private void VisitChildren(QLNode node)
{
foreach (var child in node.Children)
{
child.Accept(this);
}
}
public bool Analyse(QLNode node)
{
var result = true;
var expression = GetExpression(node);
if (expression != null && AnalyseExpression(expression) == StatementType.Unknown)
{
Analyser.AddMessage(string.Format("{0} - This expression isn't valid.", node.Location), Language.QL, MessageType.ERROR);
return(false);
}
switch (node)
{
case QLCollectionNode collectionNode:
foreach (QLNode child in collectionNode.Children)
{
if (!Analyse(child))
{
result = false;
}
}
break;
default:
return(true);
}
return(result);
}
/// <summary>
/// A recursive function to find out if the AST contains multiple FormNode
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public bool Analyse(QLNode node)
{
//Reset the formNodeCount
formNodeCount = 0;
if (node.Type == NodeType.Form)
{
this.Visit(node as FormNode);
}
else
{
this.Visit(node);
}
this.Visit(node);
if (formNodeCount == 0)
{
Analyser.AddMessage("There has no form been defined", Language.QL, MessageType.ERROR);
}
else if (formNodeCount > 1)
{
Analyser.AddMessage("There can only be one form", Language.QL, MessageType.ERROR);
}
return(formNodeCount == 1);
}
public bool Analyse(QLNode node)
{
this._isValid = true;
this.Visit((dynamic)node);
return(this._isValid);
}
/// <summary>
/// Parses Node recursively
/// </summary>
/// <param name="node">Node to parse</param>
/// <param name="condition">Base condition, optional</param>
/// <returns>Collection of widgets</returns>
public static ElementManager ParseChildNode(QLNode node, ElementManagerController elementManagerController, ElementManagerCollection parent, ExpressionBool condition = null)
{
ExpressionFactory expressionFactory = new ExpressionFactory(elementManagerController);
switch (node)
{
case ConditionalNode conditionalNode:
// Parse condition
ExpressionBool newCondition = expressionFactory.GetCondition(conditionalNode);
newCondition = (condition == null) ? newCondition : condition.Combine(newCondition, ExpressionOperator.And) as ExpressionBool;
// Add children with new condition
parent.AddChildren(conditionalNode.Children.Select(o => ParseChildNode(o, elementManagerController, parent, newCondition)).Where(o => o != null));
return(null);
case QuestionNode questionNode:
return(CreateElementManager(questionNode, condition, parent, elementManagerController, null));
case ComputedNode computedNode:
ExpressionValue expression = expressionFactory.ParseExpressionNode(computedNode.Expression);
return(CreateElementManager(computedNode, condition, parent, elementManagerController, expression));
}
throw new NotImplementedException();
}
/// <summary>
/// This function will return true if it doesn't encounter any problems.
/// </summary>
public bool Analyse(QLNode node)
{
// Reset the Analyser
this.VisitedIDs.Clear();
// This visit discovers all the identifiers.
this.Visit((dynamic)node);
return(VisitedIDs.Count == VisitedIDs.Distinct().Count());
}
public static bool Analyse(QLNode qlNode, QLSNode qlsNode)
{
Reset();
if (qlNode == null || qlsNode == null)
{
return(false);
}
// Analyse QL and QLS.
var result = true;
result = Analyse(qlNode) && result;
result = Analyse(qlsNode) && result;
return(result);
}
public static bool Analyse(QLNode node)
{
Reset();
if (node == null)
{
return(false);
}
var result = true;
foreach (IQLAnalyser analyser in Instance._qlAnalysers)
{
if (!analyser.Analyse(node) && result)
{
result = false;
}
}
return(result);
}
/// <summary>
/// This function gets the expresion from several type of nodes.
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
private IExpressionNode GetExpression(QLNode node)
{
switch (node.GetNodeType())
{
case NodeType.Conditional:
var conditional = (ConditionalNode)node;
return(conditional.Expression);
case NodeType.Computed:
var computed = (ComputedNode)node;
return(computed.Expression);
case NodeType.ArthimetricExpression:
case NodeType.ComparisonExpression:
case NodeType.LogicalExpression:
return(node as IExpressionNode);
default:
return(null);
}
}
public void Visit(QLNode node)
{
VisitChildren(node);
}
public bool Analyse(QLNode node)
{
isValid = true;
this.Visit(node);
return(isValid);
}
public void Visit(QLNode node)
{
return;
}
