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