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()); }