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 ImportPackage(fieldName)); state.AddStatement(new OpenPackage(fieldName)); 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 block in getBlock(state) select(comparisand, expression, block); if (result.ValueOrCast <Unit>(out var tuple, out var asUnit)) { state.CommitTransaction(); var(comparisand, expression, block) = tuple; state.AddStatement(new ConditionalWhile(comparisand, expression, block)); return(Unit.Matched()); } else { state.RollBackTransaction(); return(asUnit); } }
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens) { state.Colorize(tokens, Color.Keyword, Color.Whitespace); state.AddStatement(new ReturnNothing()); return(Unit.Matched()); }
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens) { state.Colorize(tokens, Color.Whitespace); state.AddStatement(new EndOfLine()); return(Unit.Matched()); }
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens) { state.Colorize(tokens, Color.Keyword); Block block; if (state.CurrentSource.IsMatch(REGEX_EOL)) { if (getBlock(state).ValueOrCast <Unit>(out block, out var asUnit)) { } else { return(asUnit); } } else if (getExpression(state, ExpressionFlags.Standard).ValueOrCast <Unit>(out var expression, out var asUnit)) { block = new Block(new ExpressionStatement(expression, true)); } else { return(asUnit); } block.AddReturnIf(); state.AddStatement(new Defer(block)); return(Unit.Matched()); }
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens) { state.BeginTransaction(); var isNew = tokens[1].Text.IsNotEmpty(); var mutable = tokens[1].Text == "var"; var fieldName = tokens[3].Text; state.Colorize(tokens, Color.Keyword, Color.Whitespace, Color.Identifier); var result = from typeConstraint in parseTypeConstraint(state) from scanned in state.Scan($"^ /(|s|) /'=' /(|s|) /'loop' /({REGEX_EOL})", Color.Whitespace, Color.Structure, Color.Whitespace, Color.Keyword, Color.Whitespace) from block in getBlock(state) from pair in getReturn(state) select(typeConstraint, block, pair); if (result.If(out var tuple, out _)) { var(typeConstraint, block, (condition, expression)) = tuple; state.AddStatement(new AssignFromLoop(isNew, mutable, fieldName, typeConstraint, block, condition, expression)); state.CommitTransaction(); return(Unit.Matched()); } else { state.RollBackTransaction(); return(notMatched <Unit>()); } }
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens) { state.Colorize(tokens, Color.Keyword); state.AddStatement(new Skip()); return(Unit.Matched()); }
public override IMatched <Unit> Suffix(ParseState state, Expression expression, Block block) { var elseIf = none <If>(); var elseIfParser = new ElseIfParser(fieldName, mutable, assignment); if (elseIfParser.Scan(state).If(out _, out var _exception)) { elseIf = elseIfParser.If; } else if (_exception.If(out var exception)) { return(failedMatch <Unit>(exception)); } var elseBlock = none <Block>(); var elseParser = new ElseParser(); if (elseParser.Scan(state).If(out _, out _exception)) { elseBlock = elseParser.Block; } else if (_exception.If(out var exception)) { return(failedMatch <Unit>(exception)); } state.AddStatement(new If(expression, block, elseIf, elseBlock, fieldName, mutable, assignment, true)); return(Unit.Matched()); }
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens) { var name = tokens[3].Text; state.Colorize(tokens, Color.Keyword, Color.Whitespace, Color.Class, Color.OpenParenthesis); state.CreateReturnType(); var result = from parameters in getParameters(state) from block in getAnyBlock(state) select(parameters, block); if (result.ValueOrCast <Unit>(out var anyResult, out var asUnit)) { state.RemoveReturnType(); state.RegisterPattern(name); state.AddStatement(new Pattern(name, anyResult.parameters, anyResult.block)); return(Unit.Matched()); } else { state.RemoveReturnType(); return(asUnit); } }
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens) { state.BeginTransaction(); state.Colorize(tokens, Color.Keyword); var result = from skipped in state.SkipEndOfLine() from b in getBlock(state) from e in getUntil(state) select(b, e); if (result.ValueOrCast <Unit>(out var tuple, out var asUnit)) { var(block, expression) = tuple; state.AddStatement(new Loop(block, expression)); state.CommitTransaction(); return(Unit.Matched()); } else { state.RollBackTransaction(); return(asUnit); } }
public override IMatched <Unit> Suffix(ParseState state, Expression expression) { if (all) { var placeholderName = newLabel("yieldIndex"); var block = new Block(new Yield(new Expression(new FieldSymbol(placeholderName)))); var @for = new For(new PlaceholderSymbol("-" + placeholderName), expression, block); state.AddStatement(@for); } else { state.AddStatement(new Yield(expression)); } state.SetYieldFlag(); return(Unit.Matched()); }
protected static IMatched <Unit> getMatchFunction(ParseState state, string functionName, Parameters parameters, bool overriding, string className) { var list = new List <If>(); if (state.Advance().ValueOrOriginal(out _, out var original)) { state.CreateReturnType(); while (state.More) { var caseParser = new CaseParser(parameters[0].Name); state.SkipEndOfLine(); if (caseParser.Scan(state).If(out _, out var anyException)) { caseParser.If.AddReturnIf(); list.Add(caseParser.If); } else if (anyException.If(out var exception)) { state.Regress(); return(failedMatch <Unit>(exception)); } else { break; } } if (list.Count == 0) { state.Regress(); state.RemoveReturnType(); return(notMatched <Unit>()); } else { var stack = new Stack <If>(); foreach (var ifStatement in list) { stack.Push(ifStatement); } var previousIf = stack.Pop(); while (stack.Count > 0) { var current = stack.Pop(); current.ElseIf = previousIf.Some(); previousIf = current; } state.AddStatement(new MatchFunction(functionName, parameters, previousIf, overriding, className)); state.Regress(); state.RemoveReturnType(); return(Unit.Matched()); } }
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens) { var className = tokens[3].Text; state.Colorize(tokens, Color.Keyword, Color.Whitespace, Color.Class, Color.Whitespace); var parameters = Parameters.Empty; var parentClassName = ""; var arguments = new Expression[0]; Module.Global.ForwardReference(className); var builder = new ClassBuilder(className, parameters, parentClassName, arguments, false, new Block(), new List <Mixin>()); if (builder.Register().ValueOrOriginal(out _, out var registerOriginal)) { var cls = new Class(builder); state.AddStatement(cls); if (getBlock(state).ValueOrCast <Unit>(out var block, out var asUnit)) { var metaClassName = $"__$meta{className}"; var metaClassBuilder = new ClassBuilder(metaClassName, Parameters.Empty, "", new Expression[0], false, block, new List <Mixin>()); if (metaClassBuilder.Register().ValueOrOriginal(out _, out registerOriginal)) { var metaClass = new MetaClass(className, metaClassBuilder); state.AddStatement(metaClass); return(Unit.Matched()); } else { return(registerOriginal); } } else { return(asUnit); } }
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> 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> ParseStatement(ParseState state, Token[] tokens) { var mutable = tokens[1].Text == "var"; var fieldName = tokens[3].Text; var assignment = fieldName.IsNotEmpty(); state.Colorize(tokens, Color.Keyword, Color.Whitespace, Color.Identifier, Color.Whitespace, Color.Structure, Color.Whitespace, Color.Keyword, Color.Whitespace); if (getExpression(state, ExpressionFlags.Standard).ValueOrCast <Unit>(out var expression, out var asUnit)) { var matchField = newLabel("match"); state.AddStatement(new AssignToNewField(false, matchField, expression)); state.Advance(); var caseParser = new CaseParser(fieldName, mutable, assignment, matchField, true, CaseType.Statement); if (caseParser.Scan(state).ValueOrOriginal(out _, out asUnit)) { var ifStatement = caseParser.If; addMatchElse(ifStatement); state.AddStatement(ifStatement); state.Regress(); return(Unit.Matched()); } else { state.Regress(); return(asUnit); } } else { return(asUnit); } }
public override IMatched <Unit> Suffix(ParseState state, Expression expression) { var assignmentOperation = none <Operation>(); if (matchOperator(operationSource).If(out var operation, out var _exception)) { assignmentOperation = operation.Some(); } else if (_exception.If(out var exception)) { return(failedMatch <Unit>(exception)); } state.AddStatement(new AssignToField(fieldName, assignmentOperation, expression)); return(Unit.Matched()); }
public override IMatched <Unit> Suffix(ParseState state, Expression expression) { var block = new Block(new Pass()); var result = from keyword in state.Scan("^ /(|s+|) /'else'", Color.Whitespace, Color.Keyword) from eBlock in getBlock(state) select eBlock; if (result.ValueOrCast <Unit>(out var elseBlock, out var asUnit)) { state.AddStatement(new If(expression, block, none <If>(), elseBlock.Some(), "", false, false, true)); return(Unit.Matched()); } else { return(asUnit); } }
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens) { var flags = ExpressionFlags.Standard; if (returnExpression) { flags |= ExpressionFlags.OmitSendMessageAssign; } if (getExpression(state, flags).ValueOrCast <Unit>(out var expression, out var asUnit)) { state.AddStatement(new ExpressionStatement(expression, returnExpression, _typeConstraint)); return(Unit.Matched()); } else { return(asUnit); } }
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens) { state.Colorize(tokens, Color.Keyword); var result = from expression in getExpression(state, ExpressionFlags.Standard) from block in getBlock(state) select new While(expression, block); if (result.ValueOrCast <Unit>(out var statement, out var asUnit)) { state.AddStatement(statement); return(Unit.Matched()); } else { return(asUnit); } }
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens) { state.BeginTransaction(); var result = from comparisand in getExpression(state, ExpressionFlags.Comparisand | ExpressionFlags.OmitColon) from stem in state.Scan("^ /(|s|) /':='", Color.Whitespace, Color.Structure) from expression in getExpression(state, ExpressionFlags.Standard) select(comparisand, expression); if (result.If(out var tuple, out var anyException)) { state.CommitTransaction(); var(comparisand, expression) = tuple; state.AddStatement(new MatchAssign(comparisand, expression)); return(Unit.Matched()); } else if (anyException.If(out var exception) && exception.Message != "Invalid expression syntax") { state.RollBackTransaction(); return(failedMatch <Unit>(exception)); }
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens) { state.Colorize(tokens, Color.Keyword); var result = from expression in getExpression(state, ExpressionFlags.Standard) from scanned in state.Scan($"^ /(|s+|) /'times' {REGEX_ANTICIPATE_END}", Color.Whitespace, Color.Keyword) from block in getBlock(state) select(expression, block); if (result.If(out var tuple)) { var(expression, block) = tuple; state.AddStatement(new Repeat(expression, block)); return(Unit.Matched()); } else { return(result.UnmatchedOnly <Unit>()); } }
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens) { state.Colorize(tokens, Color.Keyword, Color.Whitespace); var result = from comparisand in getExpression(state, ExpressionFlags.Comparisand | ExpressionFlags.OmitColon) from scanned in state.Scan("^ /(|s|) /':='", Color.Whitespace, Color.Structure) from source in getExpression(state, ExpressionFlags.Standard) from block in getBlock(state) select(comparisand, source, block); if (result.ValueOrCast <Unit>(out var tuple, out var asUnit)) { var(comparisand, source, block) = tuple; state.AddStatement(new For(comparisand, source, block)); return(Unit.Matched()); } else { return(asUnit); } }
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens) { var className = tokens[3].Text; state.Colorize(tokens, Color.Keyword, Color.Whitespace, Color.Class, Color.OpenParenthesis); if (getParameters(state).ValueOrCast <Unit>(out var parameters, out var asUnit)) { var parentClassParser = new ParentClassParser(); var parentClassName = ""; var arguments = new Expression[0]; if (parentClassParser.Scan(state).If(out _, out var anyException)) { (parentClassName, _, arguments) = parentClassParser.Parent; } else if (anyException.If(out var exception)) { return(failedMatch <Unit>(exception)); } Module.Global.ForwardReference(className); var builder = new ClassBuilder(className, parameters, parentClassName, arguments, false, new Block(), new List <Mixin>()); if (builder.Register().ValueOrOriginal(out _, out var original)) { var cls = new Class(builder); state.AddStatement(cls); return(Unit.Matched()); } else { return(original); } }
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens) { var className = tokens[3].Text; Module.Global.ForwardReference(className); state.Colorize(tokens, Color.Keyword, Color.Whitespace, Color.Class); state.SkipEndOfLine(); state.Advance(); var mixins = new List <Mixin>(); while (state.More) { var mixinIncludesParser = new MixinIncludesParser(mixins); if (mixinIncludesParser.Scan(state).If(out _, out var anyException)) { } else if (anyException.If(out var exception)) { state.Regress(); return(failedMatch <Unit>(exception)); } else { break; } } state.SkipEndOfLine(); state.Regress(); if (getBlock(state).ValueOrCast <Unit>(out var block, out var asUnit)) { var builder = new ClassBuilder(className, Parameters.Empty, "", new Expression[0], false, block, mixins); if (builder.Register().ValueOrOriginal(out _, out asUnit)) { var cls = new Class(builder); state.AddStatement(cls); var classItemsParser = new ClassItemsParser(builder); while (state.More) { if (classItemsParser.Scan(state).If(out _, out var anyException)) { } else if (anyException.If(out var exception)) { return(failedMatch <Unit>(exception)); } else { break; } } Module.Global.RegisterMixin(new Mixin(className)); return(Unit.Matched()); } else { return(asUnit); } } else { return(asUnit); } }
public override IMatched <Unit> Suffix(ParseState state, Expression expression) { state.AddStatement(new AssignToNewField(mutable, fieldName, expression, _typeConstraint)); return(Unit.Matched()); }
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens) { var overriding = tokens[1].Text.StartsWith("override"); var isOperator = tokens[2].Text == "op"; var isMacro = tokens[2].Text == "def"; var className = tokens[4].Text; if (className.IsEmpty() && TraitName.IsNotEmpty()) { className = TraitName; } var functionName = tokens[6].Text; var type = tokens[7].Text; if (isOperator && !Module.Global.RegisterOperator(functionName)) { return($"Operator {functionName} already registered".FailedMatch <Unit>()); } var needsParameters = type == "("; if (needsParameters) { state.Colorize(tokens, Color.Keyword, Color.Keyword, Color.Whitespace, Color.Class, Color.Structure, Color.Invokable, Color.OpenParenthesis); if (functionName.IsMatch("^ /w+ '=' $")) { functionName = $"__${functionName.Drop(-1)}="; } } else { state.Colorize(tokens, Color.Keyword, Color.Keyword, Color.Whitespace, Color.Class, Color.Structure, Color.Invokable); functionName = $"__${functionName}"; } state.CreateYieldFlag(); state.CreateReturnType(); if (GetAnyParameters(needsParameters, state).ValueOrCast <Unit>(out var parameters, out var asUnit)) { if (state.CurrentSource.IsMatch("^ /s* '|'")) { return(getMatchFunction(state, functionName, parameters, overriding, className)); } else if (state.CurrentSource.StartsWith("(")) { return(getCurriedFunction(state, functionName, parameters, overriding, className).Map(f => { if (isMacro) { state.RegisterMacro(f); } else { state.AddStatement(f); } return Unit.Matched(); })); } else { return(getAnyBlock(state).Map(block => { var yielding = state.RemoveYieldFlag(); state.RemoveReturnType(); var function = new Function(functionName, parameters, block, yielding, overriding, className); if (isMacro) { state.RegisterMacro(function); } else { state.AddStatement(function); } return Unit.Matched(); })); } } else { return(asUnit); } }
public override IMatched <Unit> Suffix(ParseState state, Expression expression) { state.AddStatement(new Return(expression, state.GetReturnType())); return(Unit.Matched()); }
public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens) { var className = tokens[3].Text; var hasParameters = tokens[4].Text == "("; state.Colorize(tokens, Color.Keyword, Color.Whitespace, Color.Class, Color.OpenParenthesis); Parameters parameters; if (hasParameters) { if (getParameters(state).ValueOrCast <Unit>(out parameters, out var asUnit)) { } else if (asUnit.IsNotMatched) { parameters = new Parameters(0); } else { return(asUnit); } } else { parameters = Parameters.Empty; } state.SkipEndOfLine(); state.Advance(); var parentClassParser = new ParentClassParser(); var parentClassName = ""; var initialize = false; var arguments = new Expression[0]; if (parentClassParser.Scan(state).If(out _, out var anyException)) { (parentClassName, initialize, arguments) = parentClassParser.Parent; } else if (anyException.If(out var exception)) { state.Regress(); return(failedMatch <Unit>(exception)); } var mixins = new List <Mixin>(); while (state.More) { var mixinIncludesParser = new MixinIncludesParser(mixins); if (mixinIncludesParser.Scan(state).If(out _, out anyException)) { } else if (anyException.If(out var exception)) { state.Regress(); return(failedMatch <Unit>(exception)); } else { break; } } state.SkipEndOfLine(); state.Regress(); Module.Global.ForwardReference(className); state.SkipEndOfLine(); if (getBlock(state).ValueOrCast <Unit>(out var block, out var asUnit2)) { var builder = new ClassBuilder(className, parameters, parentClassName, arguments, initialize, block, mixins); if (builder.Register().ValueOrOriginal(out _, out asUnit2)) { var cls = new Class(builder); state.AddStatement(cls); var classItemsParser = new ClassItemsParser(builder); while (state.More) { if (classItemsParser.Scan(state).If(out _, out anyException)) { } else if (anyException.If(out var exception)) { return(failedMatch <Unit>(exception)); } else { break; } } return(Unit.Matched()); } else { return(asUnit2); } } else { return(asUnit2); } }