/// <summary>
/// Ensure the expressions in a template expression is not using special path encoding
/// </summary>
public override void VisitTemplateExpression(TemplateExpression node)
{
Writer.AppendToken("`");
AppendNode(node.Head);
if (!node.TemplateSpans.IsNullOrEmpty())
{
foreach (var span in node.TemplateSpans.AsStructEnumerable())
{
var previousIsInSpecialPathContext = IsInPathLiteralContext;
Writer.AppendToken("${");
// When going into expression mode disable the specialPathContext
IsInPathLiteralContext = false;
AppendNode(span.Expression);
IsInPathLiteralContext = previousIsInSpecialPathContext;
Writer.AppendToken("}");
AppendNode(span.Literal);
}
}
Writer.AppendToken("`");
}
private static object?Evaluate(Expression expression, IDictionary <string, object> properties)
{
return(expression switch
{
TextExpression text => text.Value,
ConstantExpression constant => constant.Value,
PipeExpression pipe => PipeValue(pipe, properties),
TemplateExpression part => EvaluateTemplate(part, properties),
PropertyExpression property => GetProperty(property, properties),
FunctionCallExpression function => CallFunction(function, properties),
MultiTemplateExpression => throw new NotSupportedException("Multi-template expressions are top-level expressions only."),
_ => throw new NotImplementedException(string.Format(Strings.EvaluationNotImplemented, expression)),
});
public CSharpSyntaxNode Convert(TemplateExpression node)
{
SyntaxList <InterpolatedStringContentSyntax> contents = new SyntaxList <InterpolatedStringContentSyntax>();
InterpolatedStringContentSyntax head = node.Head.ToCsNode <InterpolatedStringContentSyntax>();
if (head != null)
{
contents = contents.Add(head);
}
foreach (Node templateSpan in node.TemplateSpans)
{
var content = templateSpan.ToCsNode <SyntaxList <InterpolatedStringContentSyntax> >();
contents = contents.AddRange(content);
}
return(SyntaxFactory.InterpolatedStringExpression(SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken), contents));
}
private static int CompareTaggedTemplateExpression(ITaggedTemplateExpression left, ITaggedTemplateExpression right)
{
// Standard left,right and null checks
if (left == null && right == null)
{
return(0);
}
if (left == null)
{
return(1);
}
if (right == null)
{
return(-1);
}
// Compare tag
var result = CompareNodeAsText(left.Tag, right.Tag);
if (result != 0)
{
return(result);
}
// Special case check for path literal.
var interpolationKind = left.GetInterpolationKind();
bool usePathCompareSemantics = false;
switch (interpolationKind)
{
case InterpolationKind.PathInterpolation:
case InterpolationKind.FileInterpolation:
case InterpolationKind.DirectoryInterpolation:
case InterpolationKind.RelativePathInterpolation:
usePathCompareSemantics = true;
break;
}
var leftIsLiteral = IsTemplateLiteral(left.TemplateExpression);
var rightIsLiteral = IsTemplateLiteral(right.TemplateExpression);
ITemplateExpression leftTemplate;
ITemplateExpression rightTemplate;
if (leftIsLiteral)
{
if (rightIsLiteral)
{
return(CompareStringLiteralExpression(left.TemplateExpression.Cast <ILiteralExpression>(), right.TemplateExpression.Cast <ILiteralExpression>(), usePathCompareSemantics));
}
leftTemplate = new TemplateExpression()
{
Head = new TemplateLiteralFragment()
{
Text = left.TemplateExpression.GetTemplateText()
}, TemplateSpans = NodeArray <ITemplateSpan> .Empty
};
rightTemplate = right.TemplateExpression.Cast <ITemplateExpression>();
}
else if (rightIsLiteral)
{
leftTemplate = left.TemplateExpression.Cast <ITemplateExpression>();
rightTemplate = new TemplateExpression()
{
Head = new TemplateLiteralFragment()
{
Text = right.TemplateExpression.GetTemplateText()
}, TemplateSpans = NodeArray <ITemplateSpan> .Empty
};
}
else
{
leftTemplate = left.TemplateExpression.Cast <ITemplateExpression>();
rightTemplate = right.TemplateExpression.Cast <ITemplateExpression>();
}
return(CompareTemplateExpression(leftTemplate, rightTemplate, usePathCompareSemantics));
}
public static string GetId(this TemplateExpression expression)
{
var language = expression.Language.ToString() ?? _defaultLanguage;
return($"{expression.Value}-{language}");
}
public Paging( TemplateExpression expression, SqlDbUtility dbUtility, int pageSize )
{
_expression = expression;
_dbUtility = dbUtility;
PageSize = pageSize;
}
public SqlServerPagingDataSource( TemplateExpression expression, SqlDbUtility dbUtility )
{
_expression = expression;
_dbUtility = dbUtility;
}
public IPagingDataSource MakePageSource( TemplateExpression expression, SqlDbUtility dbUtility )
{
return new SqlServerPagingDataSource( expression, dbUtility );
}
public static ParsedCode Parse(string code, Dictionary <string, object> variables = null, InterpreterOptions opts = null)
{
code = code.Replace("\r", ""); //todo this might cause throws in osx.
StringSpan output_sb;
var output = new LineBuilder(output_sb = StringSpan.Create(code));
variables = variables ?? new Dictionary <string, object>();
opts = opts ?? new InterpreterOptions();
// Define the context of our expression
var ew = new ExpressionWalker(ExpressionLexer.Tokenize(code).Where(t => t.Token != ExpressionToken.UnixNewLine).ToList());
//if no tokens detected
if (ew.Count == 0)
{
return(new ParsedCode()
{
OriginalCode = code, Output = output, Variables = variables, Options = opts, ParseActions = new OList <ParserAction>(0)
});
}
var parserTokens = new OList <ParserAction>();
do
{
var current = ew.Current;
switch (ew.Current.Token)
{
case ExpressionToken.Mod: {
//copypastes.Add(sb.Substring(from, ew.Current.Match.Index + ew.Current.Match.Length - 1));
current = ew.NextToken();
if (current == null)
{
break;
}
switch (current.Token)
{
case ExpressionToken.Template: {
//this is import %import namespace.type as aliasnmae
var template = TemplateExpression.Parse(ew);
parserTokens += new ParserAction(ParserToken.Template, output.MarkDeleteLinesRelated(template.Matches()), template);
break;
}
case ExpressionToken.Import: {
//this is import %import namespace.type as aliasnmae
var import = ImportExpression.Parse(ew);
parserTokens += new ParserAction(ParserToken.Import, output.MarkDeleteLinesRelated(import.Matches()), import);
break;
}
case ExpressionToken.Literal: {
//this is variable declaration %varname = expr
var peak = ew.PeakNext.Token;
if (peak == ExpressionToken.Equal)
{
var expr = VariableDeclarationExpression.Parse(ew);
parserTokens += new ParserAction(ParserToken.Declaration, output.MarkDeleteLinesRelated(expr.Matches()), expr);
}
else
{
break;
}
break;
}
case ExpressionToken.LeftParen: {
//it is an expression block %(expr)
ew.NextOrThrow();
var expr = Expression.ParseExpression(ew);
parserTokens += new ParserAction(ParserToken.Expression, output.MarkDeleteLinesRelated(expr.Matches()), expr);
ew.IsCurrentOrThrow(ExpressionToken.RightParen);
ew.Next();
break;
}
case ExpressionToken.Foreach: {
parserTokens += ForeachExpression.Parse(ew, code, output);
break;
}
case ExpressionToken.CommentRow:
//skip untill we hit newline
ew.SkipForwardWhile(t => t.Token != ExpressionToken.NewLine); //todo test
break;
default: {
var precentageLine = output.GetLineAt(ew.PeakBack.Match.Index);
if (precentageLine.CleanContent() != "%")
{
throw new UnexpectedTokenException(current.Token, $"The given token was not expected at line {precentageLine.LineNumber}, offset: {current.Match.Index - precentageLine.StartIndex}");
}
break;
}
}
break;
}
default:
break;
}
} while (ew.Next());
return(new ParsedCode()
{
OriginalCode = code,
Output = output,
Variables = variables,
ETokens = (List <TokenMatch>)ew.Walking,
ParseActions = parserTokens,
Options = opts
});
}
