public void TestAppendString()
{
var expr = new KeywordExpression("for");
var builder = new StringBuilder();
expr.AppendString(builder);
Assert.That(builder.ToString(), Is.EqualTo("for"));
}
protected virtual void Visit(KeywordExpression keywordExpression)
{
// A discard will be transformed to 'return'
if (keywordExpression.Name.Text == "discard")
{
Write("return");
}
else
{
base.Visit(keywordExpression);
}
}
static bool TryParseAtomic(ref TokenParser parser,
[MaybeNullWhen(returnValue: false)] out Expression expr)
{
// We can parse keywords, parameter names and constants
expr = null;
if (parser.TryParseKeywordLowerCase("this.startingvalue"))
{
expr = new KeywordExpression(ExpressionKeyword.StartingValue);
}
else if (parser.TryParseKeywordLowerCase("this.currentvalue"))
{
expr = new KeywordExpression(ExpressionKeyword.CurrentValue);
}
else if (parser.TryParseKeywordLowerCase("this.finalvalue"))
{
expr = new KeywordExpression(ExpressionKeyword.FinalValue);
}
else if (parser.TryParseKeywordLowerCase("pi"))
{
expr = new KeywordExpression(ExpressionKeyword.Pi);
}
else if (parser.TryParseKeywordLowerCase("true"))
{
expr = new KeywordExpression(ExpressionKeyword.True);
}
else if (parser.TryParseKeywordLowerCase("false"))
{
expr = new KeywordExpression(ExpressionKeyword.False);
}
else if (parser.TryParseKeywordLowerCase("this.target"))
{
expr = new KeywordExpression(ExpressionKeyword.Target);
}
if (expr != null)
{
return(true);
}
if (parser.TryParseIdentifier(out var identifier))
{
expr = new ParameterExpression(identifier.ToString());
return(true);
}
if (parser.TryParseFloat(out var scalar))
{
expr = new ConstantExpression(scalar);
return(true);
}
return(false);
}
/// <summary>
/// Visits the specified keyword expression.
/// </summary>
/// <param name="keywordExpression">The keyword expression.</param>
public override void Visit(KeywordExpression keywordExpression)
{
// A discard will be transformed to 'return'
if (keywordExpression.Name.Text == "discard")
{
WriteLinkLine(keywordExpression);
WriteLine("context.Discard();");
}
else
{
base.Visit(keywordExpression);
}
}
/// <summary>
/// Checks for errors before applying a rule.
/// </summary>
/// <param name="node">The node instance to check.</param>
/// <param name="dataList">Optional data collected during inspection of sources.</param>
/// <param name="data">Private data to give to Apply() upon return.</param>
/// <returns>True if an error occured.</returns>
public override bool CheckConsistency(IKeywordExpression node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
bool Success = true;
Success &= KeywordExpression.ResolveCompilerReferences(node, ErrorList, out IResultType ResolvedResult, out IResultException ResolvedException, out ISealableList <IExpression> ConstantSourceList, out ILanguageConstant ExpressionConstant);
if (Success)
{
data = new Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant>(ResolvedResult, ResolvedException, ConstantSourceList, ExpressionConstant);
}
return(Success);
}
public override void Visit(KeywordExpression expression)
{
if (expression.Name.Text == keyword)
{
var list = new List <Statement>(containerStack);
list.Reverse();
if (ParentNode is ExpressionStatement)
{
list.Add(ParentNode as ExpressionStatement);
}
else
{
parserResult.Error("{0} keyword detected, but outside of an ExpressionStatement. It is impossible to unroll the loop", expression.Span, keyword);
}
scopeList.Add(list);
}
}
/// <summary>
/// Checks for errors before applying a rule.
/// </summary>
/// <param name="node">The node instance to check.</param>
/// <param name="dataList">Optional data collected during inspection of sources.</param>
/// <param name="data">Private data to give to Apply() upon return.</param>
/// <returns>True if an error occured.</returns>
public override bool CheckConsistency(IKeywordAnchoredType node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
bool Success = true;
data = null;
// The 'Current' case is handled in KeywordAnchoredTypeCurrentRuleTemplate.
if (node.Anchor != BaseNode.Keyword.Current)
{
IClass EmbeddingClass = node.EmbeddingClass;
IErrorList CheckErrorList = new ErrorList();
if (!KeywordExpression.IsKeywordAvailable(node.Anchor, node, CheckErrorList, out ITypeName ResultTypeName, out ICompiledType ResultType))
{
AddSourceErrorList(CheckErrorList);
Success = false;
}
else
{
data = new Tuple <ITypeName, ICompiledType>(ResultTypeName, ResultType);
}
}
/// <summary>
/// Checks for errors before applying a rule.
/// </summary>
/// <param name="node">The node instance to check.</param>
/// <param name="dataList">Optional data collected during inspection of sources.</param>
/// <param name="data">Private data to give to Apply() upon return.</param>
/// <returns>True if an error occured.</returns>
public override bool CheckConsistency(IKeywordAnchoredType node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
bool Success = true;
data = null;
if (node.Anchor == BaseNode.Keyword.Current)
{
IClass EmbeddingClass = node.EmbeddingClass;
IErrorList CheckErrorList = new ErrorList();
// 'Current' is always available.
Success = KeywordExpression.IsKeywordAvailable(node.Anchor, node, CheckErrorList, out ITypeName ResultTypeName, out ICompiledType ResultType);
Debug.Assert(Success);
data = new Tuple <ITypeName, ICompiledType>(ResultTypeName, ResultType);
}
else
{
data = new Tuple <ITypeName, ICompiledType>(Class.ClassAny.ResolvedClassTypeName.Item, Class.ClassAny.ResolvedClassType.Item);
}
return(Success);
}
public override void Visit(KeywordExpression expression)
{
_expressionString.Append(" KEYWORD(PROP=");
Visit(expression.Property);
_expressionString.Append(", PHRASE=");
Visit(expression.Phrase);
_expressionString.Append(")");
}
private static KeywordExpression Clone(KeywordExpression expression)
{
return(expression);
}