private Expression Suffix(INode node)
{
if (node.Name == "quantified")
{
Debug.Assert(node.Count == 2);
var expression = Primary(node[0]);
switch (node[1].Name)
{
case "?":
return(OptionalExpression.From(node, expression));
case "*":
return(StarExpression.From(node, expression));
case "+":
return(PlusExpression.From(node, expression));
default:
throw new NotImplementedException();
}
}
return(Primary(node));
}
protected override void VisitOptionalExpression(OptionalExpression optional)
{
CS.IndentInOut(
"OptionalExpression",
() =>
{
VisitExpression(optional.Expression);
using var node = Locals.Use("node");
CS.Ln($"{node} = NodeList.From({Locals.Result}, NodeSymbols.Optional, {Locals.Result}.Nodes.ToArray());");
CS.If(
$"{Locals.Result}.IsSuccess",
() => CS.Ln($"{Locals.Result} = Result.Success({Locals.Result}, {Locals.Result}.Next, {node});"),
() => CS.Ln($"{Locals.Result} = Result.Success({Cfg.CurName}, {Cfg.CurName}, {node});"));
});
}
private ParseAction ImportOptionalExpression(Expression exp,
Entity entity,
ParseAction parent = null,
bool optional = false)
{
OptionalExpression option = ((OptionalExpression)exp);
// recurse down
ParseAction consume = this.ImportPropertiesAndParseActions(
option.Expression, entity, parent, true
);
// mark optional
consume.IsOptional = true;
return(consume);
}
/// <summary>
/// RenderAny create-table column
/// </summary>
/// <param name="writer">to render to</param>
public void ToEPL(TextWriter writer)
{
writer.Write(ColumnName);
writer.Write(" ");
if (OptionalExpression != null)
{
OptionalExpression.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM);
}
else
{
writer.Write(OptionalTypeName);
if (OptionalTypeIsArray != null && OptionalTypeIsArray.Value)
{
if (OptionalTypeIsPrimitiveArray != null && OptionalTypeIsPrimitiveArray.Value)
{
writer.Write("[primitive]");
}
else
{
writer.Write("[]");
}
}
if (PrimaryKey.GetValueOrDefault())
{
writer.Write(" primary key");
}
}
if (Annotations != null && !Annotations.IsEmpty())
{
writer.Write(" ");
string delimiter = "";
foreach (AnnotationPart part in Annotations)
{
if (part.Name == null)
{
continue;
}
writer.Write(delimiter);
delimiter = " ";
part.ToEPL(writer);
}
}
}
private static Expression Expression(INode node)
{
switch (node.Name)
{
case "sequence": return(Sequence(node));
case "choice": return(Choice(node));
case "prefix.drop": return(DropExpression.From(node[0], Expression(node[0])));
case "prefix.lift": return(LiftExpression.From(node[0], Expression(node[0])));
case "prefix.fuse": return(FuseExpression.From(node[0], Expression(node[0])));
case "prefix.not": return(NotExpression.From(node[0], Expression(node[0])));
case "suffix.zero-or-more": return(StarExpression.From(node[0], Expression(node[0])));
case "suffix.one-or-more": return(PlusExpression.From(node[0], Expression(node[0])));
case "suffix.zero-or-one": return(OptionalExpression.From(node[0], Expression(node[0])));
case "inline": return(InlineExpression.From(node[0], Tree.Rule.From(Identifier(node[0]), Expression(node[1]))));
case "identifier": return(NameExpression.From(node, Identifier(node)));
case "any": return(AnyExpression.From(node));
case "verbatim-string": return(StringLiteralExpression.From(node, ((ILeaf)node).Value));
case "character-class": return(Class(node));
case "string": return(String(node));
default:
throw new NotImplementedException();
}
}
private string GenerateOptionalExpression(Expression expression)
{
OptionalExpression optional = expression as OptionalExpression;
return("[ " + this.GenerateExpression(optional.Expression) + " ]");
}
protected override void VisitOptionalExpression(OptionalExpression expression)
{
MaybeParent(expression.Expression is PrefixExpression, expression.Expression);
Writer.Write($"{OpSymbols.Option}");
}
protected override void VisitOptionalExpression(OptionalExpression optional)
{
VisitExpression(optional.Expression);
Push(new Parsers.Optional(Pop()));
}
