void EmitLink(LinkRef lref)
{
RxLinkRef link = lref as RxLinkRef;
link.PushOffsetPosition(curpos);
Emit((ushort)0);
}
public void EmitIn(LinkRef tail)
{
// emitted for things like [\dabcfh]
BeginLink(tail);
Emit(RxOp.TestCharGroup);
EmitLink(tail);
}
public void EmitIfDefined(int gid, LinkRef tail)
{
BeginLink(tail);
Emit(OpCode.IfDefined);
EmitLink(tail);
Emit((ushort)gid);
}
public void EmitAnchor(bool reverse, int offset, LinkRef tail)
{
this.BeginLink(tail);
this.Emit(OpCode.Anchor, PatternCompiler.MakeFlags(false, false, reverse, false));
this.EmitLink(tail);
this.Emit((ushort)offset);
}
public void EmitAnchor(bool reverse, int offset, LinkRef tail)
{
BeginLink(tail);
Emit(OpCode.Anchor, MakeFlags(negate: false, ignore: false, reverse, lazy: false));
EmitLink(tail);
Emit((ushort)offset);
}
public void EmitUntil(LinkRef repeat)
{
ResolveLink(repeat);
Emit(OpCode.Until);
TraceRegexp("end until {0}", repeat);
}
private void EmitLink(LinkRef lref)
{
PatternCompiler.PatternLinkStack patternLinkStack = (PatternCompiler.PatternLinkStack)lref;
patternLinkStack.OffsetAddress = this.CurrentAddress;
this.Emit(0);
patternLinkStack.Push();
}
public void EmitTest(LinkRef yes, LinkRef tail)
{
this.BeginLink(yes);
this.BeginLink(tail);
this.Emit(OpCode.Test);
this.EmitLink(yes);
this.EmitLink(tail);
}
public void EmitRepeat(int min, int max, bool lazy, LinkRef until)
{
BeginLink(until);
Emit(OpCode.Repeat, MakeFlags(false, false, false, lazy));
EmitLink(until);
EmitCount(min);
EmitCount(max);
}
public void EmitTest(LinkRef yes, LinkRef tail)
{
BeginLink(yes);
BeginLink(tail);
Emit(OpCode.Test);
EmitLink(yes);
EmitLink(tail);
}
public void EmitFastRepeat(int min, int max, bool lazy, LinkRef tail)
{
BeginLink(tail);
Emit(OpCode.FastRepeat, MakeFlags(negate: false, ignore: false, reverse: false, lazy));
EmitLink(tail);
EmitCount(min);
EmitCount(max);
}
public void EmitRepeat(int min, int max, bool lazy, LinkRef until)
{
BeginLink(until);
Emit(lazy ? RxOp.RepeatLazy : RxOp.Repeat);
EmitLink(until);
Emit(min);
Emit(max);
}
public void EmitBranch(LinkRef next)
{
BeginLink(next);
Emit(OpCode.Branch, 0);
EmitLink(next);
TraceRegexp("branch next {0}", next);
}
public void EmitJump(LinkRef target)
{
BeginLink(target);
Emit(OpCode.Jump, 0);
EmitLink(target);
TraceRegexp("jmp target {0}", target);
}
public void EmitIn(LinkRef tail)
{
BeginLink(tail);
Emit(OpCode.In);
EmitLink(tail);
TraceRegexp("in tail {0}", tail);
}
public void ResolveLink(LinkRef lref)
{
PatternCompiler.PatternLinkStack patternLinkStack = (PatternCompiler.PatternLinkStack)lref;
while (patternLinkStack.Pop())
{
this.pgm[patternLinkStack.OffsetAddress] = (ushort)patternLinkStack.GetOffset(this.CurrentAddress);
}
}
public void EmitFastRepeat(int min, int max, bool lazy, LinkRef tail)
{
BeginLink(tail);
Emit(lazy ? RxOp.FastRepeatLazy : RxOp.FastRepeat);
EmitLink(tail);
Emit(min);
Emit(max);
}
public void EmitFastRepeat(int min, int max, bool lazy, LinkRef tail)
{
BeginLink(tail);
Emit(OpCode.FastRepeat, MakeFlags(false, false, false, lazy));
EmitLink(tail);
Emit((ushort)min);
Emit((ushort)max);
}
public void EmitSub(LinkRef tail)
{
BeginLink(tail);
Emit(OpCode.Sub);
EmitLink(tail);
TraceRegexp("sub {0}", tail);
}
public void EmitFastRepeat(int min, int max, bool lazy, LinkRef tail)
{
this.BeginLink(tail);
this.Emit(OpCode.FastRepeat, PatternCompiler.MakeFlags(false, false, false, lazy));
this.EmitLink(tail);
this.EmitCount(min);
this.EmitCount(max);
}
private void EmitLink(LinkRef lref)
{
PatternLinkStack patternLinkStack = (PatternLinkStack)lref;
patternLinkStack.OffsetAddress = CurrentAddress;
Emit((ushort)0);
patternLinkStack.Push();
}
private void EmitLink(LinkRef lref)
{
PatternLinkStack stack = (PatternLinkStack)lref;
stack.OffsetAddress = CurrentAddress;
Emit((ushort)0); // placeholder
stack.Push();
}
public void EmitBalanceStart(int gid, int balance, bool capture, LinkRef tail)
{
this.BeginLink(tail);
this.Emit(OpCode.BalanceStart);
this.Emit((ushort)gid);
this.Emit((ushort)balance);
this.Emit((!capture) ? 0 : 1);
this.EmitLink(tail);
}
public void EmitIfDefined(int gid, LinkRef tail)
{
BeginLink(tail);
Emit(OpCode.IfDefined);
EmitLink(tail);
Emit((ushort)gid);
TraceRegexp("if defined gid {1} tail {2}", gid, tail);
}
public void EmitBalanceStart(int gid, int balance, bool capture, LinkRef tail)
{
BeginLink(tail);
Emit(OpCode.BalanceStart);
Emit((ushort)gid);
Emit((ushort)balance);
Emit((ushort)(capture ? 1 : 0));
EmitLink(tail);
}
public void EmitAnchor(bool reverse, int offset, LinkRef tail)
{
BeginLink(tail);
Emit(OpCode.Anchor, MakeFlags(false, false, reverse, false));
EmitLink(tail);
Emit((ushort)offset);
TraceRegexp("anchor reverse {0} offset {1} tail {2}", reverse, offset, tail);
}
public void ResolveLink(LinkRef lref)
{
PatternLinkStack stack = (PatternLinkStack)lref;
while (stack.Pop())
{
pgm[stack.OffsetAddress] = (ushort)stack.GetOffset(CurrentAddress);
}
}
public void EmitJumpTest(LinkRef target, LinkRef ElseTarget)
{
BeginLink(target);
BeginLink(ElseTarget);
Emit(OpCode.JumpTest, 0);
EmitLink(target);
EmitLink(ElseTarget);
TraceRegexp("jmp test target {0} if not already tried else {1} ", target, ElseTarget);
}
public void EmitFastRepeat(int min, int max, bool lazy, LinkRef tail)
{
BeginLink(tail);
Emit(OpCode.FastRepeat, MakeFlags(false, false, false, lazy));
EmitLink(tail);
EmitCount(min);
EmitCount(max);
TraceRegexp("repeat-fast min {0} max {1} lazy {2} tail {3}", min, max, lazy, tail);
}
public void EmitTest(LinkRef yes, LinkRef tail)
{
BeginLink(yes);
BeginLink(tail);
Emit(OpCode.Test);
EmitLink(yes);
EmitLink(tail);
TraceRegexp("test yes {0} tail {1}", yes, tail);
}
public void EmitJump (LinkRef target) {
BeginLink (target);
Emit (OpCode.Jump, 0);
EmitLink (target);
}
public void EmitJumpTest (LinkRef target, LinkRef ElseTarget) {
BeginLink (target);
BeginLink (ElseTarget);
Emit (OpCode.JumpTest, 0);
EmitLink (target);
EmitLink (ElseTarget);
TraceRegexp ("jmp test target {0} if not already tried else {1} ", target,ElseTarget);
}
public void EmitAnchor (bool reverse, int offset, LinkRef tail) {
BeginLink (tail);
Emit (OpCode.Anchor, MakeFlags(false, false, reverse, false));
EmitLink (tail);
Emit ((ushort)offset);
TraceRegexp ("anchor reverse {0} offset {1} tail {2}", reverse, offset, tail);
}
public void EmitIn (LinkRef tail) {
BeginLink (tail);
Emit (OpCode.In);
EmitLink (tail);
TraceRegexp ("in tail {0}", tail);
}
void BeginLink (LinkRef lref) {
RxLinkRef link = lref as RxLinkRef;
link.PushInstructionBase (curpos);
}
public void EmitIfDefined (int gid, LinkRef tail) {
BeginLink (tail);
Emit (OpCode.IfDefined);
EmitLink (tail);
Emit ((ushort)gid);
TraceRegexp ("if defined gid {1} tail {2}", gid, tail);
}
public void EmitFastRepeat (int min, int max, bool lazy, LinkRef tail) {
BeginLink (tail);
Emit (OpCode.FastRepeat, MakeFlags (false, false, false, lazy));
EmitLink (tail);
EmitCount (min);
EmitCount (max);
TraceRegexp ("repeat-fast min {0} max {1} lazy {2} tail {3}", min, max, lazy, tail);
}
public void EmitUntil (LinkRef repeat) {
ResolveLink (repeat);
Emit (OpCode.Until);
TraceRegexp ("end until {0}", repeat);
}
public void EmitTest (LinkRef yes, LinkRef tail) {
BeginLink (yes);
BeginLink (tail);
Emit (OpCode.Test);
EmitLink (yes);
EmitLink (tail);
TraceRegexp ("test yes {0} tail {1}", yes, tail);
}
public void EmitBranch (LinkRef next) {
BeginLink (next);
Emit (OpCode.Branch, 0);
EmitLink (next);
}
public void EmitTest (LinkRef yes, LinkRef tail) {
BeginLink (yes);
BeginLink (tail);
Emit (OpCode.Test);
EmitLink (yes);
EmitLink (tail);
}
public void EmitJump (LinkRef target) {
BeginLink (target);
Emit (OpCode.Jump, 0);
EmitLink (target);
TraceRegexp ("jmp target {0}", target);
}
public void EmitIfDefined (int gid, LinkRef tail) {
BeginLink (tail);
Emit (OpCode.IfDefined);
EmitLink (tail);
Emit ((ushort)gid);
}
public void EmitBalanceStart (int gid, int balance, bool capture, LinkRef tail) {
BeginLink (tail);
Emit (OpCode.BalanceStart);
Emit ((ushort)gid);
Emit ((ushort)balance);
Emit ((ushort)(capture ? 1 : 0));
EmitLink (tail);
}
public void EmitBranch (LinkRef next) {
BeginLink (next);
Emit (OpCode.Branch, 0);
EmitLink (next);
TraceRegexp ("branch next {0}", next);
}
public void EmitUntil (LinkRef repeat) {
ResolveLink (repeat);
Emit (OpCode.Until);
}
public void EmitSub (LinkRef tail) {
BeginLink (tail);
Emit (OpCode.Sub);
EmitLink (tail);
TraceRegexp ("sub {0}", tail);
}
public void EmitFastRepeat (int min, int max, bool lazy, LinkRef tail) {
BeginLink (tail);
Emit (OpCode.FastRepeat, MakeFlags (false, false, false, lazy));
EmitLink (tail);
EmitCount (min);
EmitCount (max);
}
public void EmitBalanceStart (int gid, int balance, bool capture, LinkRef tail) {
BeginLink (tail);
Emit (OpCode.BalanceStart);
Emit ((ushort)gid);
Emit ((ushort)balance);
Emit ((ushort)(capture ? 1 : 0));
EmitLink (tail);
TraceRegexp ("balance start gid {0} balance {1} capture {2} tail {3}", gid, balance, capture, tail);
}
public void EmitIn (LinkRef tail) {
BeginLink (tail);
Emit (OpCode.In);
EmitLink (tail);
}
static void TraceRegexpLabel (LinkRef lref)
{
Console.Write ("{0}:", lref);
}
public void EmitAnchor (bool reverse, int offset, LinkRef tail) {
BeginLink (tail);
Emit (OpCode.Anchor, MakeFlags(false, false, reverse, false));
EmitLink (tail);
Emit ((ushort)offset);
}
void EmitLink (LinkRef lref)
{
RxLinkRef link = lref as RxLinkRef;
link.PushOffsetPosition (curpos);
Emit ((ushort)0);
}
public void ResolveLink (LinkRef lref) {
PatternLinkStack stack = (PatternLinkStack)lref;
while (stack.Pop ())
pgm[stack.OffsetAddress] = (ushort)stack.GetOffset (CurrentAddress);
}
public void ResolveLink (LinkRef link)
{
RxLinkRef l = link as RxLinkRef;
for (int i = 0; i < l.current; i += 2) {
int offset = curpos - l.offsets [i];
if (offset > ushort.MaxValue)
throw new NotSupportedException ();
int offsetpos = l.offsets [i + 1];
program [offsetpos] = (byte)offset;
program [offsetpos + 1] = (byte)(offset >> 8);
}
}
private void BeginLink (LinkRef lref) {
PatternLinkStack stack = (PatternLinkStack)lref;
stack.BaseAddress = CurrentAddress;
}
public void EmitAnchor (bool reverse, int offset, LinkRef tail)
{
BeginLink (tail);
if (reverse)
Emit (RxOp.AnchorReverse);
else
Emit (RxOp.Anchor);
EmitLink (tail);
if (offset > ushort.MaxValue)
throw new NotSupportedException ();
Emit ((ushort)offset);
}
private void EmitLink (LinkRef lref) {
PatternLinkStack stack = (PatternLinkStack)lref;
stack.OffsetAddress = CurrentAddress;
Emit ((ushort)0); // placeholder
stack.Push ();
}
public void EmitSub (LinkRef tail) {
BeginLink (tail);
Emit (OpCode.Sub);
EmitLink (tail);
}
public void EmitRepeat (int min, int max, bool lazy, LinkRef until) {
BeginLink (until);
Emit (OpCode.Repeat, MakeFlags (false, false, false, lazy));
EmitLink (until);
Emit ((ushort)min);
Emit ((ushort)max);
}
