SearchEntry top; //stack entry
#endregion Fields
#region Constructors
internal Matcher(Pattern regex)
{
this.re=regex;
int memregCount, counterCount, lookaheadCount;
if((memregCount=regex.memregs)>0) {
MemReg[] memregs = new MemReg[memregCount];
for(int i=0;i<memregCount;i++){
memregs[i]=new MemReg(-1); //unlikely to SearchEntry, in this case we know memreg indicies by definition
}
this.memregs=memregs;
}
if((counterCount=regex.counters)>0) counters = new int[counterCount];
if((lookaheadCount=regex.lookaheads)>0) {
LAEntry[] lookaheads=new LAEntry[lookaheadCount];
for(int i=0;i<lookaheadCount;i++){
lookaheads[i] = new LAEntry();
}
this.lookaheads = lookaheads;
}
first = new SearchEntry();
defaultEntry = new SearchEntry();
minQueueLength = regex.stringRepr.Length/2; // just evaluation!!!
}
static PerlSubstitution()
{
try {
refPtn = new Pattern(groupRef);
NAME_ID = refPtn.GroupId("name");
ESC_ID = refPtn.GroupId("esc");
} catch(PatternSyntaxException e){
System.Console.Error.WriteLine(e.StackTrace);
}
}
Regexp(string pattern, Pattern regexp, string flags)
{
this.pattern = pattern;
this.regexp = regexp;
this.flags = flags;
}
public override void Init(IokeObject obj)
{
Runtime runtime = obj.runtime;
obj.Kind = "Text";
obj.Mimics(IokeObject.As(runtime.Mixins.GetCell(null, null, "Comparing"), null), runtime.nul, runtime.nul);
obj.SetCell("==", runtime.Base.Cells["=="]);
obj.RegisterMethod(runtime.NewNativeMethod("Returns a text representation of the object",
new NativeMethod.WithNoArguments("asText",
(method, context, message, on, outer) => {
outer.ArgumentsDefinition.GetEvaluatedArguments(context, message, on, new SaneArrayList(), new SaneDictionary<string, object>());
return on;
})));
obj.RegisterMethod(runtime.NewNativeMethod("Takes any number of arguments, and expects the text receiver to contain format specifications. The currently supported specifications are only %s and %{, %}. These have several parameters that can be used. See the spec for more info about these. The format method will return a new text based on the content of the receiver, and the arguments given.",
new TypeCheckingNativeMethod("format", TypeCheckingArgumentsDefinition.builder()
.ReceiverMustMimic(obj)
.WithRest("replacements")
.Arguments,
(self, on, args, keywords, context, message) => {
StringBuilder result = new StringBuilder();
Format(on, message, context, args, result);
return context.runtime.NewText(result.ToString());
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("Converts the content of this text into a rational value",
new TypeCheckingNativeMethod.WithNoArguments("toRational", obj,
(self, on, args, keywords, context, message) => {
return Text.ToRational(on, context, message);
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("Converts the content of this text into a decimal value",
new TypeCheckingNativeMethod.WithNoArguments("toDecimal", obj,
(self, on, args, keywords, context, message) => {
return Text.ToDecimal(on, context, message);
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("Returns a text inspection of the object",
new TypeCheckingNativeMethod.WithNoArguments("inspect", obj,
(self, on, args, keywords, context, message) => {
return self.runtime.NewText(Text.GetInspect(on));
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("Returns a brief text inspection of the object",
new TypeCheckingNativeMethod.WithNoArguments("notice", obj,
(self, on, args, keywords, context, message) => {
return self.runtime.NewText(Text.GetInspect(on));
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("Returns a lower case version of this text",
new TypeCheckingNativeMethod.WithNoArguments("lower", obj,
(self, on, args, keywords, context, message) => {
return self.runtime.NewText(Text.GetText(on).ToLower());
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("Returns an upper case version of this text",
new TypeCheckingNativeMethod.WithNoArguments("upper", obj,
(self, on, args, keywords, context, message) => {
return self.runtime.NewText(Text.GetText(on).ToUpper());
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("Returns a version of this text with leading and trailing whitespace removed",
new TypeCheckingNativeMethod.WithNoArguments("trim", obj,
(self, on, args, keywords, context, message) => {
return self.runtime.NewText(Text.GetText(on).Trim());
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("Returns an array of texts split around the argument",
new TypeCheckingNativeMethod("split", TypeCheckingArgumentsDefinition.builder()
.ReceiverMustMimic(obj)
.WithOptionalPositional("splitAround", "")
.Arguments,
(self, on, args, keywords, context, message) => {
string real = Text.GetText(on);
var r = new SaneArrayList();
Pattern p = null;
if(args.Count == 0) {
p = new Pattern("\\s");
} else {
object arg = args[0];
if(IokeObject.dataOf(arg) is Regexp) {
p = Regexp.GetRegexp(arg);
} else {
string around = Text.GetText(arg);
p = new Pattern(Pattern.Quote(around));
}
}
RETokenizer tok = new RETokenizer(p, real);
tok.EmptyEnabled = false;
while(tok.HasMore) {
r.Add(context.runtime.NewText(tok.NextToken));
}
return context.runtime.NewList(r);
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("Takes two text arguments where the first is the substring to replace, and the second is the replacement to insert. Will only replace the first match, if any is found, and return a new Text with the result.",
new TypeCheckingNativeMethod("replace", TypeCheckingArgumentsDefinition.builder()
.ReceiverMustMimic(obj)
.WithRequiredPositional("pattern")
.WithRequiredPositional("replacement")
.Arguments,
(self, on, args, keywords, context, message) => {
string initial = Text.GetText(on);
string repl = Text.GetText(args[1]);
object arg = args[0];
Pattern pat = null;
if(IokeObject.dataOf(arg) is Regexp) {
pat = Regexp.GetRegexp(arg);
} else {
string around = Text.GetText(arg);
pat = new Pattern(Pattern.Quote(around));
}
Replacer r = pat.Replacer(repl);
string result = r.ReplaceFirst(initial);
return context.runtime.NewText(result);
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("Takes two text arguments where the first is the substring to replace, and the second is the replacement to insert. Will replace all matches, if any is found, and return a new Text with the result.",
new TypeCheckingNativeMethod("replaceAll", TypeCheckingArgumentsDefinition.builder()
.ReceiverMustMimic(obj)
.WithRequiredPositional("pattern")
.WithRequiredPositional("replacement")
.Arguments,
(self, on, args, keywords, context, message) => {
string initial = Text.GetText(on);
string repl = Text.GetText(args[1]);
object arg = args[0];
Pattern pat = null;
if(IokeObject.dataOf(arg) is Regexp) {
pat = Regexp.GetRegexp(arg);
} else {
string around = Text.GetText(arg);
pat = new Pattern(Pattern.Quote(around));
}
Replacer r = pat.Replacer(repl);
String result = r.Replace(initial);
return context.runtime.NewText(result);
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("Returns the length of this text",
new TypeCheckingNativeMethod.WithNoArguments("length", obj,
(self, on, args, keywords, context, message) => {
return context.runtime.NewNumber(GetText(on).Length);
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("compares this text against the argument, returning -1, 0 or 1 based on which one is lexically larger",
new TypeCheckingNativeMethod("<=>", TypeCheckingArgumentsDefinition.builder()
.ReceiverMustMimic(obj)
.WithRequiredPositional("other")
.Arguments,
(self, on, args, keywords, context, message) => {
object arg = args[0];
if(!(IokeObject.dataOf(arg) is Text)) {
arg = IokeObject.ConvertToText(arg, message, context, false);
if(!(IokeObject.dataOf(arg) is Text)) {
// Can't compare, so bail out
return context.runtime.nil;
}
}
if(on == context.runtime.Text || arg == context.runtime.Text) {
if(on == arg) {
return context.runtime.NewNumber(0);
}
return context.runtime.nil;
}
int result = string.CompareOrdinal(Text.GetText(on), Text.GetText(arg));
if(result < 0) {
result = -1;
} else if(result > 0) {
result = 1;
}
return context.runtime.NewNumber(result);
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("takes one argument, that can be either an index or a range of two indicis. this slicing works the same as for Lists, so you can index from the end, both with the single index and with the range.",
new TypeCheckingNativeMethod("[]", TypeCheckingArgumentsDefinition.builder()
.ReceiverMustMimic(obj)
.WithRequiredPositional("index")
.Arguments,
(self, on, args, keywords, context, message) => {
object arg = args[0];
IokeData data = IokeObject.dataOf(arg);
if(data is Range) {
int first = Number.ExtractInt(Range.GetFrom(arg), message, context);
if(first < 0) {
return context.runtime.NewText("");
}
int last = Number.ExtractInt(Range.GetTo(arg), message, context);
bool inclusive = Range.IsInclusive(arg);
string str = GetText(on);
int size = str.Length;
if(last < 0) {
last = size + last;
}
if(last < 0) {
return context.runtime.NewText("");
}
if(last >= size) {
last = inclusive ? size-1 : size;
}
if(first > last || (!inclusive && first == last)) {
return context.runtime.NewText("");
}
if(!inclusive) {
last--;
}
return context.runtime.NewText(str.Substring(first, (last+1)-first));
} else if(data is Number) {
string str = GetText(on);
int len = str.Length;
int ix = ((Number)data).AsNativeInteger();
if(ix < 0) {
ix = len + ix;
}
if(ix >= 0 && ix < len) {
return context.runtime.NewNumber(str[ix]);
} else {
return context.runtime.nil;
}
}
return on;
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("Returns a symbol representing the Unicode category of the character",
new TypeCheckingNativeMethod.WithNoArguments("category", obj,
(self, on, args, keywords, context, message) => {
string character = GetText(on);
if(character.Length == 1) {
return context.runtime.GetSymbol(UnicodeBlock.Of(character[0]));
}
IokeObject condition = IokeObject.As(IokeObject.GetCellChain(runtime.Condition,
message,
context,
"Error",
"Default"), context).Mimic(message, context);
condition.SetCell("message", message);
condition.SetCell("context", context);
condition.SetCell("receiver", on);
condition.SetCell("text", context.runtime.NewText("Text does not contain exactly one character"));
runtime.ErrorCondition(condition);
return null;
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("Returns a new text where all the escapes in the current text have been evaluated - exactly as if another parsing step had been applied. This does not evaluate embedded code, though.",
new TypeCheckingNativeMethod.WithNoArguments("evaluateEscapes", obj,
(self, on, args, keywords, context, message) => {
return context.runtime.NewText(new StringUtils().ReplaceEscapes(GetText(on)));
})));
}
public Replacer(Pattern pattern, string substitution, bool isPerlExpr)
{
this.pattern =pattern;
this.substitution = isPerlExpr ? (Substitution)new PerlSubstitution(substitution) : new DummySubstitution(substitution);
}
public Replacer(Pattern pattern, string substitution)
: this(pattern,substitution,true)
{
}
public Replacer(Pattern pattern, Substitution substitution)
{
this.pattern=pattern;
this.substitution=substitution;
}
