public static FunctionCall Call(MatchIterator iterator)
{
// It would be cool in patterner v2 if the pattern was constructed in the same method as the finalizer.
// For example, a "dummy" matchIterator could be passed through here and pick up the requirements, perhaps?
// This would, of course, require the big feature of pattern simplification
// It would also require defining a special "Expression" subpattern? At this point it would be better if everything were an expression, I guess
iterator.AssertTokenType(TokenType.Name, out Token name);
iterator.AssertKeySymbol(Symbols.OpenBracket, out _);
Token open = (Token)iterator.Current;
if (iterator.Next(out List <Expression> arguments))
{
iterator.MoveNext();
}
else
{
arguments = new List <Expression>();
}
iterator.AssertKeySymbol(Symbols.CloseBracket, out _);
Token end = (Token)iterator.Current;
iterator.AssertEnd();
FunctionCall result = new FunctionCall(name, open, end, arguments);
return(result);
}
public static FunctionHeader Header(MatchIterator iterator)
{
iterator.AssertTokenType(TokenType.Type, out Token typeToken);
iterator.AssertTokenType(TokenType.Name, out Token nameToken);
iterator.AssertKeySymbol(Symbols.OpenBracket, out _);
Token open = (Token)iterator.Current;
CollectedParameters parameters;
if (iterator.Next(out parameters))
{
iterator.MoveNext();
}
else
{
parameters = new CollectedParameters();
}
iterator.AssertKeySymbol(Symbols.CloseBracket, out _);
Token end = (Token)iterator.Current;
iterator.AssertEnd();
FunctionTypeSignature typeSignature = new FunctionTypeSignature(parameters.Types);
FunctionSignature signature = new FunctionSignature(
FunctionSignature.Local, nameToken.Content, typeSignature);
FunctionHeader result = new FunctionHeader(
typeToken, nameToken, open, end, signature, parameters.Names);
return(result);
}
public static VariableAssignment Assignment(MatchIterator iterator)
{
if (!iterator.NextIsToken(TokenType.Type, out Token type))
{
type = null;
}
iterator.AssertTokenType(TokenType.Name, out Token name);
if (iterator.Next(out List <CollectedIndex> indices))
{
iterator.MoveNext();
}
else
{
indices = new List <CollectedIndex>(0);
}
iterator.AssertTokenType(TokenType.Operator, out Token op);
if (!iterator.NextIsExpression(out Expression value))
{
value = null;
}
iterator.AssertEnd();
return(new VariableAssignment(type, name, indices, op, value));
}
public static VariableReference CreateReference(MatchIterator iterator)
{
iterator.AssertTokenType(TokenType.Name, out Token token);
iterator.AssertEnd();
return(new VariableReference(token));
}
public static LiteralGet Create(MatchIterator iterator)
{
iterator.AssertToken(out Token token);
LiteralGet result = new LiteralGet(token);
iterator.AssertEnd();
return(result);
}
public static Expression CreateOld(MatchIterator iterator)
{
Token opToken;
if (iterator.NextIsToken(TokenType.Operator, out opToken))
{
// assume a left operator for now
Expression righExpr = Create(iterator);
return(new OperatorCall(opToken, null, righExpr));
}
Expression nextExpr;
if (iterator.NextIsKeySymbol(Symbols.OpenBracket))
{
iterator.AssertExpression(out nextExpr);
iterator.AssertKeySymbol(Symbols.CloseBracket, out _);
}
else
{
iterator.AssertExpression(out nextExpr);
}
if (iterator.AtEnd())
{
return(nextExpr);
}
if (iterator.Next(out List <CollectedIndex> indices))
{
foreach (CollectedIndex index in indices)
{
nextExpr = new Indexer(nextExpr, index.Open, index.Index, index.Close);
}
iterator.MoveNext();
}
if (iterator.AtEnd())
{
return(nextExpr);
}
iterator.AssertTokenType(TokenType.Operator, out opToken);
if (iterator.AtEnd())
{
// Assume a right operator for now
return(new OperatorCall(opToken, nextExpr, null));
}
// Assume a binary operator for now
Expression remainder = Create(iterator);
return(new OperatorCall(opToken, nextExpr, remainder));
}
public static ElseHeader Else(MatchIterator iterator)
{
iterator.AssertKeyword(Keywords.Else, out Token elseToken);
iterator.AssertEnd();
ElseHeader result = new ElseHeader(elseToken);
return(result);
}
public static Command Create(MatchIterator iterator)
{
iterator.AssertTokenType(TokenType.KeyWord, out Token keyWord);
iterator.AssertEnd();
Command result = new Command(keyWord);
return(result);
}
public static IfHeader If(MatchIterator iterator)
{
iterator.AssertKeyword(Keywords.If, out Token ifToken);
iterator.AssertExpression(out Expression condition);
iterator.AssertEnd();
IfHeader result = new IfHeader(ifToken, condition);
return(result);
}
public static ElseIfHeader ElseIf(MatchIterator iterator)
{
iterator.AssertKeyword(Keywords.Else, out Token elseToken);
iterator.AssertKeyword(Keywords.If, out Token ifToken);
iterator.AssertExpression(out Expression condition);
iterator.AssertEnd();
ElseIfHeader result = new ElseIfHeader(elseToken, ifToken, condition);
return(result);
}
public static LoopHeader Loop(MatchIterator iterator)
{
Expression array;
iterator.AssertKeyword(Keywords.Loop);
Token loop = (Token)iterator.Current;
if (iterator.AtEnd())
{
LoopHeader result = new LoopHeader(loop);
return(result);
}
iterator.AssertExpression(out Expression firstExpression);
if (iterator.AtEnd())
{
// Actually checking that this expression is an array is for
// a later step, when the messenger is available.
array = firstExpression;
LoopHeader result = new LoopHeader(loop, array);
return(result);
}
if (iterator.NextIsKeyword(Keywords.In, out Token inToken))
{
// Again, actually checking that this is indeed just a name
// has to wait for a later stage.
Expression name = firstExpression;
iterator.AssertExpression(out array);
iterator.AssertEnd();
LoopHeader result = new LoopHeader(loop, name, inToken, array);
return(result);
}
if (iterator.NextIsKeyword(Keywords.From, out Token from))
{
Expression name = firstExpression;
iterator.AssertExpression(out Expression start);
iterator.AssertKeyword(Keywords.To, out Token to);
iterator.AssertExpression(out Expression end);
iterator.AssertEnd();
LoopHeader result = new LoopHeader(
loop, name, from, start, to, end);
return(result);
}
throw iterator.UnexpectedEnd();
}
public static Return Return(MatchIterator iterator)
{
iterator.AssertKeyword(Keywords.Return);
Token startToken = (Token)iterator.Current;
Expression expression;
iterator.NextIsExpression(out expression);
iterator.AssertEnd();
Return result = new Return(startToken, expression);
return(result);
}
private static Expression GetValue(MatchIterator iterator)
{
if (iterator.NextIsToken(TokenType.Operator, out Token opToken))
{
// Early out: if we are starting with an operator, than it is
// a right unary operator, and unary ops have the highest
// precedence at the moment.
return(new OperatorCall(opToken, null, GetValue(iterator)));
}
Expression expression;
// We don't have to recursively descend through the brackets -
// that is handled at the pattern matching level. As far as we are
// concerned, there are either expressions or expressions wrapped
// in brackets.
if (iterator.NextIsKeySymbol(Symbols.OpenBracket, out Token open))
{
iterator.AssertExpression(out Expression value);
iterator.AssertKeySymbol(Symbols.CloseBracket, out Token close);
expression = new Group(open, value, close);
}
else
{
iterator.AssertExpression(out expression);
}
// Finally, consider any indexing that follow the expression.
// Sprak only allows one level of this, but that will be enforced
// later where a more friendly error can be displayed.
if (iterator.Next(out List <CollectedIndex> indices))
{
foreach (CollectedIndex index in indices)
{
expression = new Indexer(expression, index.Open, index.Index, index.Close);
}
iterator.MoveNext();
}
return(expression);
}
public static List <Expression> Arguments(MatchIterator iterator)
{
List <Expression> arguments = new List <Expression>();
if (iterator.AtEnd())
{
return(arguments);
}
do
{
iterator.AssertExpression(out Expression argument);
arguments.Add(argument);
}while (iterator.NextIsKeySymbol(Symbols.Comma));
iterator.AssertEnd();
return(arguments);
}
public static LiteralArrayGet CreateArray(MatchIterator iterator)
{
Token start, end;
iterator.AssertKeySymbol(Symbols.OpenSquareBracket, out _);
start = (Token)iterator.Current;
if (iterator.Next(out List <Expression> elements))
{
iterator.MoveNext();
}
else
{
elements = new List <Expression>();
}
iterator.AssertKeySymbol(Symbols.CloseSquareBracket, out _);
end = (Token)iterator.Current;
return(new LiteralArrayGet(start, end, elements));
}
public static List <CollectedIndex> Indices(MatchIterator iterator)
{
List <CollectedIndex> indices = new List <CollectedIndex>();
iterator.AssertNext();
while (iterator.HasNext)
{
iterator.AssertKeySymbol(Symbols.OpenSquareBracket, out Token open);
iterator.AssertExpression(out Expression index);
iterator.AssertKeySymbol(Symbols.CloseSquareBracket, out Token close);
CollectedIndex entry = new CollectedIndex
{
Open = open,
Index = index,
Close = close
};
indices.Add(entry);
}
return(indices);
}
public static CollectedParameters Parameters(MatchIterator iterator)
{
List <SprakType> parameterTypes = new List <SprakType>();
List <string> parameterNames = new List <string>();
CollectedParameters result
= new CollectedParameters(parameterTypes, parameterNames);
if (iterator.AtEnd())
{
return(result);
}
do
{
iterator.AssertType(out SprakType type);
iterator.AssertName(out string name);
parameterTypes.Add(type);
parameterNames.Add(name);
}while (iterator.NextIsKeySymbol(Symbols.Comma));
iterator.AssertEnd();
return(result);
}
public override void Init(IokeObject obj)
{
Runtime runtime = obj.runtime;
obj.Kind = "Regexp";
IokeObject regexpMatch = new IokeObject(runtime, "contains behavior related to assignment", new RegexpMatch(obj, null, null));
regexpMatch.MimicsWithoutCheck(runtime.Origin);
regexpMatch.Init();
obj.RegisterCell("Match", regexpMatch);
obj.RegisterMethod(runtime.NewNativeMethod("returns a hash for the regexp",
new NativeMethod.WithNoArguments("hash", (method, context, message, on, outer) => {
outer.ArgumentsDefinition.CheckArgumentCount(context, message, on);
Regexp r = (Regexp)IokeObject.dataOf(on);
return(context.runtime.NewNumber(r.pattern.GetHashCode() + 13 * r.flags.GetHashCode()));
})));
obj.RegisterMethod(runtime.NewNativeMethod("returns true if the left hand side pattern is equal to the right hand side pattern.",
new TypeCheckingNativeMethod("==", TypeCheckingArgumentsDefinition.builder()
.ReceiverMustMimic(runtime.Regexp)
.WithRequiredPositional("other")
.Arguments,
(method, on, args, keywords, context, message) => {
Regexp d = (Regexp)IokeObject.dataOf(on);
object other = args[0];
return(((other is IokeObject) &&
(IokeObject.dataOf(other) is Regexp) &&
((on == context.runtime.Regexp || other == context.runtime.Regexp) ? on == other :
(d.pattern.Equals(((Regexp)IokeObject.dataOf(other)).pattern) &&
d.flags.Equals(((Regexp)IokeObject.dataOf(other)).flags)))) ? context.runtime.True : context.runtime.False);
})));
obj.RegisterMethod(runtime.NewNativeMethod("Returns the pattern use for this regular expression",
new TypeCheckingNativeMethod.WithNoArguments("pattern", obj,
(method, on, args, keywords, context, message) => {
return(context.runtime.NewText(GetPattern(on)));
})));
obj.RegisterMethod(runtime.NewNativeMethod("Takes one argument and tries to match that argument against the current pattern. Returns nil if no match can be done, or a Regexp Match object if a match succeeds",
new TypeCheckingNativeMethod("match", TypeCheckingArgumentsDefinition.builder()
.ReceiverMustMimic(obj)
.WithRequiredPositional("other")
.Arguments,
(method, on, args, keywords, context, message) => {
IokeObject target = IokeObject.As(Interpreter.Send(context.runtime.asText, context, args[0]), context);
string arg = Text.GetText(target);
Matcher m = ((Regexp)IokeObject.dataOf(on)).regexp.Matcher(arg);
if (m.Find())
{
IokeObject match = regexpMatch.AllocateCopy(message, context);
match.MimicsWithoutCheck(regexpMatch);
match.Data = new RegexpMatch(IokeObject.As(on, context), m, target);
return(match);
}
else
{
return(context.runtime.nil);
}
})));
obj.AliasMethod("match", "=~", null, null);
obj.RegisterMethod(runtime.NewNativeMethod("Takes one argument that should be a text and returns a text that has all regexp meta characters quoted",
new NativeMethod("quote", DefaultArgumentsDefinition.builder()
.WithRequiredPositional("text")
.Arguments,
(method, on, args, keywords, context, message) => {
return(context.runtime.NewText(Pattern.Quote(Text.GetText(Interpreter.Send(context.runtime.asText, context, args[0])))));
})));
obj.RegisterMethod(runtime.NewNativeMethod("Takes one or two text arguments that describes the regular expression to create. the first text is the pattern and the second is the flags.",
new NativeMethod("from", DefaultArgumentsDefinition.builder()
.WithRequiredPositional("pattern")
.WithOptionalPositional("flags", "")
.Arguments,
(method, on, args, keywords, context, message) => {
string pattern = Text.GetText(Interpreter.Send(context.runtime.asText, context, args[0]));
string flags = "";
if (args.Count > 1)
{
flags = Text.GetText(Interpreter.Send(context.runtime.asText, context, args[1]));
}
return(context.runtime.NewRegexp(pattern, flags, context, message));
})));
obj.RegisterMethod(runtime.NewNativeMethod("Takes one argument and tries to match that argument against the current pattern. Returns a list of all the texts that were matched.",
new TypeCheckingNativeMethod("allMatches", TypeCheckingArgumentsDefinition.builder()
.ReceiverMustMimic(obj)
.WithRequiredPositional("other")
.Arguments,
(method, on, args, keywords, context, message) => {
string arg = Text.GetText(Interpreter.Send(context.runtime.asText, context, args[0]));
Matcher m = ((Regexp)IokeObject.dataOf(on)).regexp.Matcher(arg);
var result = new SaneArrayList();
MatchIterator iter = m.FindAll();
while (iter.HasMore)
{
result.Add(runtime.NewText(iter.NextMatch.Group(0)));
}
return(runtime.NewList(result));
})));
obj.RegisterMethod(runtime.NewNativeMethod("Returns a text inspection of the object",
new TypeCheckingNativeMethod.WithNoArguments("inspect", obj,
(method, on, args, keywords, context, message) => {
return(method.runtime.NewText(Regexp.GetInspect(on)));
})));
obj.RegisterMethod(runtime.NewNativeMethod("Returns a brief text inspection of the object",
new TypeCheckingNativeMethod.WithNoArguments("notice", obj,
(method, on, args, keywords, context, message) => {
return(method.runtime.NewText(Regexp.GetNotice(on)));
})));
obj.RegisterMethod(runtime.NewNativeMethod("returns a list of all the named groups in this regular expression",
new TypeCheckingNativeMethod.WithNoArguments("names", obj,
(method, on, args, keywords, context, message) => {
var names = Regexp.GetRegexp(on).GroupNames;
var theNames = new SaneArrayList();
foreach (object name in names)
{
theNames.Add(context.runtime.GetSymbol(((string)name)));
}
return(context.runtime.NewList(theNames));
})));
}
public TermQuery(IPostingList postings)
{
this.postings = postings;
this.matchIterator = new MatchIterator(postings.GetEnumerator());
this.consumed = false;
}
public static Expression Create(MatchIterator iterator)
{
LinkedList <object> items = new LinkedList <object>();
iterator.AssertNext();
// postfix unary operators are not supported here
// (Like i--, etc)
// I don't think they are really needed for sprak, and defaulting
// to assuming prefix simplifies things.
while (true)
{
items.AddLast(GetValue(iterator));
if (iterator.AtEnd())
{
break;
}
iterator.AssertTokenType(TokenType.Operator, out Token op);
items.AddLast(op);
if (iterator.AtEnd())
{
break;
}
}
void ParseOperatorToken(LinkedListNode <object> opNode)
{
Token token = (Token)opNode.Value;
LinkedListNode <object> leftNode = opNode.Previous;
LinkedListNode <object> rightNode = opNode.Next;
Expression left = (Expression)leftNode.Value;
Expression right = (Expression)rightNode?.Value;
OperatorCall result = new OperatorCall(token, left, right);
items.AddBefore(leftNode, result);
items.Remove(leftNode);
items.Remove(opNode);
if (rightNode != null)
{
items.Remove(rightNode);
}
}
LinkedListNode <object> current, next;
foreach (Operator[] group in Operator.OperatorPrecedenceGroups)
{
current = items.First.Next;
while (current != null)
{
next = current.Next?.Next;
Token token = (Token)current.Value;
if (Operator.TryParse(out Operator op, text:token.Content))
{
if (group.Contains(op))
{
ParseOperatorToken(current);
}
}
current = next;
}
}
current = items.First.Next;
while (current != null)
{
ParseOperatorToken(current);
current = current.Next?.Next;
}
if (items.First.Next != null)
{
throw new Exception("Unable to parse all operators");
}
return((Expression)items.First.Value);
}
