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