public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens)
{
var fieldName = tokens[3].Text;
state.Colorize(tokens, Color.Keyword, Color.Whitespace, Color.Identifier);
state.AddStatement(new OpenPackage(fieldName));
return(Unit.Matched());
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
var index = tokens[3].Text;
state.Colorize(tokens, Color.Whitespace, Color.Identifier, Color.Identifier);
builder.Add(new FieldSymbol($"__${index}"));
return(Unit.Matched());
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
var source = tokens[3].Text;
state.Colorize(tokens, Color.Whitespace, Color.Collection, Color.Collection, Color.Collection);
builder.Add(new StringArraySymbol(source));
return(Unit.Matched());
}
public override IMatched <Unit> Prefix(ParseState state, Token[] tokens)
{
mutable = tokens[1].Text == "var";
fieldName = tokens[3].Text;
assignment = fieldName.IsNotEmpty();
state.Colorize(tokens, Color.Keyword, Color.Whitespace, Color.Identifier, Color.Whitespace, Color.Structure, Color.Whitespace,
Color.Keyword);
return(Unit.Matched());
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
state.Colorize(tokens, Color.OpenParenthesis);
return(getArguments(state, builder.Flags).Map(arguments =>
{
builder.Add(new PostfixInvokeSymbol(arguments));
return Unit.Value;
}));
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
var lazy = tokens[2].Text == "!!";
var indexed = tokens[2].Text == "?";
state.Colorize(tokens, Color.Whitespace, Color.Operator);
builder.Add(new IteratorSymbol(lazy, indexed));
return(Unit.Matched());
}
public override IMatched <Unit> ParseClassItem(ParseState state, Token[] tokens, ClassBuilder builder)
{
state.Colorize(tokens, Color.Keyword, Color.OpenParenthesis);
state.CreateReturnType();
return
(from parameters in getParameters(state)
from block in getAnyBlock(state)
from constructor in builder.Constructor(parameters, block, false)
select constructor);
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
state.Colorize(tokens, Color.Structure);
return(getArguments(state, builder.Flags).Map(e =>
{
builder.Add(new SendMessageSymbol("[?]", e));
return Unit.Value;
}));
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
var source = tokens[2].Text.Drop(1);
state.Colorize(tokens, Color.Whitespace, Color.Identifier);
Index = source.ToInt();
builder.Add(new FieldSymbol($"__${source}"));
return(Unit.Matched());
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
state.Colorize(tokens, Color.Whitespace, Color.Keyword);
return(getInternalList(state).Map(list =>
{
list.ExpandInTuple = false;
builder.Add(new InternalListSymbol(list));
return Unit.Matched();
}));
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
var source = tokens[3].Text;
var type = tokens[4].Text;
state.Colorize(tokens, Color.Whitespace, Color.NumberPart, Color.Number, Color.NumberPart);
var number = convert(source.Replace("_", ""), 2, "01");
return(getNumber(builder, type, number));
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens)
{
var skip = tokens[2].Text.Replace("_", "").DefaultTo("0");
var take = tokens[4].Text.Replace("_", "").DefaultTo("0");
state.Colorize(tokens, Color.Whitespace, Color.Number, Color.Operator, Color.Number);
Skip = skip.ToInt();
Take = take.ToInt();
if (state.Scan("^ /(|s|) /'='", Color.Whitespace, Color.Operator).IsMatched)
{
if (getExpression(state, ExpressionFlags.OmitComma).If(out var expression, out var anyException))
{
Prefix = expression.Some();
}
else if (anyException.If(out var exception))
{
return(failedMatch <Unit>(exception));
}
else
{
Prefix = none <Expression>();
}
}
else
{
Prefix = none <Expression>();
}
if (state.Scan("^ /(|s|) /'~'", Color.Whitespace, Color.Operator).IsMatched)
{
if (getExpression(state, ExpressionFlags.OmitComma | ExpressionFlags.OmitConcatenate)
.If(out var expression, out var anyException))
{
Suffix = expression.Some();
}
else if (anyException.If(out var exception))
{
return(failedMatch <Unit>(exception));
}
else
{
Suffix = none <Expression>();
}
}
else
{
Suffix = none <Expression>();
}
return(Unit.Matched());
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
var not = tokens[2].Text.Contains("not");
state.Colorize(tokens, Color.Whitespace, Color.Keyword, Color.Whitespace, Color.Keyword);
var message = not ? "notIn" : "in";
builder.Add(new SendBinaryMessageSymbol(message, Precedence.Boolean, true));
return(Unit.Matched());
}
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens)
{
state.Colorize(tokens, Color.Keyword, Color.Whitespace);
if (getBlock(state).ValueOrCast <Unit>(out var block, out var asUnit))
{
state.AddStatement(new BlockStatement(block));
return(Unit.Matched());
}
else
{
return(asUnit);
}
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
state.Colorize(tokens, Color.Whitespace, Color.Operator);
if (getTerm(state, ExpressionFlags.Comparisand).ValueOrCast <Unit>(out var expression, out var asUnit))
{
builder.Add(expression);
return(Unit.Matched());
}
else
{
return(asUnit);
}
}
public override IMatched <Unit> Prefix(ParseState state, Token[] tokens)
{
state.Colorize(tokens, Color.Keyword, Color.Whitespace);
var result =
from comparisand in getValue(state, ExpressionFlags.Comparisand)
from scanned in state.Scan("^ /(|s|) /'='", Color.Whitespace, Color.Structure)
select comparisand;
if (result.ValueOrCast <Unit>(out comparisand, out var asUnit))
{
return(Unit.Matched());
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
var insert = tokens[2].Text == "+";
state.Colorize(tokens, Color.OpenParenthesis, Color.Structure);
return(getArguments(state, builder.Flags).Map(e =>
{
if (state.Scan($"^ /(|s|) /({REGEX_ASSIGN_OPS})? /'=' -(> '=')", Color.Whitespace, Color.Operator, Color.Structure)
.If(out var opSource, out var anyException))
{
if (getExpression(state, builder.Flags).ValueOrCast <Unit>(out var expression, out var asUnit))
{
opSource = opSource.DropWhile(" ").Keep(1);
var operation = matchOperator(opSource)
.FlatMap(o => o.Some(), none <Operations.Operation>, _ => none <Operations.Operation>());
if (operation.IsNone && insert)
{
var list = e.ToList();
list.Add(expression);
builder.Add(new SendMessageSymbol("insert(at:_<Int>,value:_)", none <LambdaSymbol>(),
none <Operations.Operation>(), list.ToArray()));
}
else
{
builder.Add(new IndexSetterSymbol(e, expression, operation));
}
return Unit.Matched();
}
else
{
return asUnit;
}
}
else if (anyException.If(out var exception))
{
return failedMatch <Unit>(exception);
}
else if (e.Length > 0)
{
builder.Add(new IndexerSymbol(e));
}
else
{
return notMatched <Unit>();
}
return Unit.Matched();
}));
}
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens)
{
state.BeginTransaction();
state.Colorize(tokens, Color.Keyword, Color.Whitespace);
var result =
from comparisand in getExpression(state, ExpressionFlags.Comparisand)
from scanned in state.Scan("^ /(|s|) /':='", Color.Whitespace, Color.Structure)
from expression in getExpression(state, ExpressionFlags.Standard)
from and in getAnd(state)
from block in getBlock(state)
select(comparisand, expression, and, block);
if (result.ValueOrCast <Unit>(out var tuple, out var asUnit))
{
var(comparisand, expression, and, block) = tuple;
var elseBlock = none <Block>();
var elseParser = new ElseParser();
if (elseParser.Scan(state).If(out _, out var anyException))
{
elseBlock = elseParser.Block;
}
else if (anyException.If(out var exception))
{
state.RollBackTransaction();
return(failedMatch <Unit>(exception));
}
if (and.If(out var a))
{
var builder = new ExpressionBuilder(ExpressionFlags.Comparisand);
builder.Add(a);
if (builder.ToExpression().IfNot(out expression, out var exception))
{
state.RollBackTransaction();
return(failedMatch <Unit>(exception));
}
}
state.CommitTransaction();
state.AddStatement(new ConditionalAssign(comparisand, expression, block, elseBlock));
return(Unit.Matched());
}
else
{
state.RollBackTransaction();
return(asUnit);
}
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
state.Colorize(tokens, Color.Whitespace, Color.Collection, Color.Whitespace);
if (getExpression(state, "^ /(/s*) /')'", builder.Flags, Color.Whitespace, Color.Collection)
.ValueOrCast <Unit>(out var expression, out var asUnit))
{
builder.Add(new CycleSymbol(expression));
return(Unit.Matched());
}
else
{
return(asUnit);
}
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
var isSuccess = tokens[2].Text == "assert";
state.Colorize(tokens, Color.Whitespace, Color.Keyword);
var result =
from condition in getExpression(state, builder.Flags | ExpressionFlags.OmitColon)
from colon1 in state.Scan("^ /(|s|) /':'", Color.Whitespace, Color.Structure)
from value in getExpression(state, builder.Flags | ExpressionFlags.OmitColon)
select(condition, value);
if (isSuccess)
{
if (result.ValueOrOriginal(out var tuple, out var original))
{
var(condition, value) = tuple;
var result2 =
from colon2 in state.Scan("^ /(|s|) /':'", Color.Whitespace, Color.Structure)
from error in getExpression(state, builder.Flags | ExpressionFlags.OmitColon)
select error;
if (result2.ValueOrOriginal(out var expression, out var original2))
{
builder.Add(new AssertSymbol(condition, value, expression.Some()));
return(Unit.Matched());
}
else
{
return(original2.Unmatched <Unit>());
}
}
else
{
return(original.Unmatched <Unit>());
}
}
else if (result.ValueOrOriginal(out var tuple, out var original))
{
var(condition, value) = tuple;
builder.Add(new AssertSymbol(condition, value, none <Expression>()));
return(Unit.Matched());
}
else
{
return(original.Unmatched <Unit>());
}
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
state.Colorize(tokens, Color.Whitespace, Color.Collection, Color.Whitespace);
if (getExpression(state, $"^ /(/s*) /'{REGEX_LIST_RIGHT}'", builder.Flags & ~ExpressionFlags.OmitComma, Color.Whitespace,
Color.Collection).ValueOrCast <Unit>(out var expression, out var asUnit))
{
builder.Add(new ListSymbol(expression));
return(Unit.Matched());
}
else
{
return(asUnit.Unmatched <Unit>());
}
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
var operatorName = tokens[2].Text;
if (Module.Global.OperatorExists(operatorName))
{
state.Colorize(tokens, Color.Whitespace, Color.Operator, Color.Whitespace);
builder.Add(new OperatorSymbol(operatorName));
return(Unit.Matched());
}
else
{
return(notMatched <Unit>());
}
}
public override IMatched <Unit> Prefix(ParseState state, Token[] tokens)
{
var mutable = tokens[2].Text;
var placeholderName = tokens[4].Text;
name = mutable switch
{
"use" => placeholderName,
"var" => $"+{placeholderName}",
_ => $"-{placeholderName}"
};
state.Colorize(tokens, Color.Whitespace, Color.Keyword, Color.Whitespace, Color.Identifier, Color.Operator);
return(Unit.Matched());
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
state.Colorize(tokens, Color.Whitespace, Color.Collection, Color.Whitespace);
if (getExpression(state, "^ /(/s*) /']'", builder.Flags & ~ExpressionFlags.OmitComma, Color.Whitespace, Color.Collection)
.ValueOrOriginal(out var expression, out var original))
{
builder.Add(new ArraySymbol(expression));
return(Unit.Matched());
}
else
{
return(original.Unmatched <Unit>());
}
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
var source = tokens[3].Text;
state.Colorize(tokens, Color.Whitespace, Color.Operator, Color.Operator, Color.Operator);
if (getOperator(state, source, builder.Flags, true).ValueOrCast <Unit>(out var symbol, out var asUnit))
{
builder.Add(new ZipOperatorSymbol(symbol));
return(Unit.Matched());
}
else
{
return(asUnit);
}
}
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens)
{
var aliasName = tokens[3].Text;
var className = tokens[7].Text;
state.Colorize(tokens, Color.Keyword, Color.Whitespace, Color.Class, Color.Whitespace, Color.Structure, Color.Whitespace, Color.Class);
if (Module.Global.Alias(aliasName, className).IfNot(out var exception))
{
return(failedMatch <Unit>(exception));
}
else
{
return(Unit.Matched());
}
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
var source = tokens[2].Text;
state.Colorize(tokens, Color.Whitespace, Color.Number, Color.NumberPart);
if (byte.TryParse(source, out var b))
{
builder.Add(new ByteSymbol(b));
return(Unit.Matched());
}
else
{
return(failedMatch <Unit>(unableToConvert(source, "Byte")));
}
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
var text = tokens[3].Text;
state.Colorize(tokens, Color.Whitespace, Color.Date, Color.Date, Color.Date);
if (text.DateTime().If(out var dateTime, out var exception))
{
builder.Add(new DateSymbol(dateTime));
return(Unit.Matched());
}
else
{
return(failedMatch <Unit>(exception));
}
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
var name = tokens[3].Text;
state.Colorize(tokens, Color.Whitespace, Color.Symbol, Color.Symbol);
if (builder.Flags[ExpressionFlags.Comparisand])
{
builder.Add(new FieldSymbol(name));
}
else
{
builder.Add(new SymbolSymbol(name));
}
return(Unit.Matched());
}
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder)
{
var source = tokens[2].Text;
state.Colorize(tokens, Color.Whitespace, Color.Identifier);
if (state.DefExpression(source).If(out var defExpression))
{
builder.Add(defExpression);
}
else
{
builder.Add(builder.Flags[ExpressionFlags.Comparisand] ? new PlaceholderSymbol($"-{source}") : new FieldSymbol(source));
}
return(Unit.Matched());
}
