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> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder) { state.BeginTransaction(); state.CreateReturnType(); var result = from parameters in ParseParameters(state, tokens) from scanned in state.Scan("^ /(|s|) /'->'", Color.Whitespace, Color.Structure) from typeConstraint in parseTypeConstraint(state) from block in getLambdaBlock(!state.CurrentSource.IsMatch("^ (/r /n | /r | /n)"), state, builder.Flags & ~ExpressionFlags.Comparisand | ExpressionFlags.InLambda, typeConstraint) select new LambdaSymbol(parameters, block); if (result.ValueOrCast <Unit>(out var lambdaSymbol, out var asUnit)) { builder.Add(lambdaSymbol); state.RemoveReturnType(); state.CommitTransaction(); return(Unit.Matched()); } else { state.RollBackTransaction(); state.RemoveReturnType(); return(asUnit); } }
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> 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.Whitespace, Color.Keyword); if (builder.ToExpression().If(out var expression, out var exception)) { var comprehensions = new List <(Symbol, Expression, IMaybe <Expression>, string)>(); if (getInnerComprehension(state).ValueOrCast <Unit>(out var tuple, out var asUnit)) { var(comparisand, source, ifExp) = tuple; var image = $"for {comparisand} := {source}"; comprehensions.Add((comparisand, source, ifExp, image)); } else { return(asUnit); } while (state.More) { var parser = new InnerComprehensionParser(builder, comprehensions); if (parser.Scan(state).If(out _, out var anyException)) { } else if (anyException.If(out exception)) { return(failedMatch <Unit>(exception)); } else { break; } } var stack = new Stack <(Symbol, Expression, IMaybe <Expression>, string)>(); foreach (var item in comprehensions) { stack.Push(item); } For forStatement; var images = new StringBuilder(); if (stack.Count > 0) { var(symbol, source, ifExp, image) = stack.Pop(); images.Append(image); var yieldStatement = new Yield(expression); var block = new Block(yieldStatement); if (ifExp.If(out var boolean)) { block = new Block(new If(boolean, block)); } forStatement = new For(symbol, source, block); } else { return(notMatched <Unit>()); } while (stack.Count > 0) { var(symbol, source, ifExp, image) = stack.Pop(); images.Append(image); var block = new Block(forStatement); if (ifExp.If(out var boolean)) { block = new Block(new If(boolean, block)); } forStatement = new For(symbol, source, block); } builder.Clear(); state.CreateReturnType(); var statements = new List <Statement> { forStatement, new Return(new Expression(new NoneSymbol()), state.GetReturnType()) }; state.RemoveReturnType(); builder.Add(new ComprehensionSymbol(new Block(statements), images.ToString())); return(Unit.Matched()); } else { return(failedMatch <Unit>(exception)); } }
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); } }