public void EmitIn(LinkRef tail)
{
// emitted for things like [\dabcfh]
BeginLink(tail);
Emit(RxOp.TestCharGroup);
EmitLink(tail);
}
public void EmitUntil(LinkRef repeat)
{
ResolveLink(repeat);
Emit(OpCode.Until);
TraceRegexp("end until {0}", repeat);
}
void EmitLink(LinkRef lref)
{
RxLinkRef link = lref as RxLinkRef;
link.PushOffsetPosition(curpos);
Emit((ushort)0);
}
public void EmitTest(LinkRef yes, LinkRef tail)
{
BeginLink(yes);
BeginLink(tail);
Emit(RxOp.Test);
EmitLink(yes);
EmitLink(tail);
}
private void EmitLink(LinkRef lref)
{
PatternLinkStack stack = (PatternLinkStack)lref;
stack.OffsetAddress = CurrentAddress;
Emit((ushort)0); // placeholder
stack.Push();
}
public void EmitJump(LinkRef target)
{
BeginLink(target);
Emit(OpCode.Jump, 0);
EmitLink(target);
TraceRegexp("jmp target {0}", target);
}
public void EmitBranch(LinkRef next)
{
BeginLink(next);
Emit(OpCode.Branch, 0);
EmitLink(next);
TraceRegexp("branch next {0}", next);
}
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 EmitIn(LinkRef tail)
{
BeginLink(tail);
Emit(OpCode.In);
EmitLink(tail);
TraceRegexp("in tail {0}", tail);
}
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 EmitSub(LinkRef tail)
{
BeginLink(tail);
Emit(OpCode.Sub);
EmitLink(tail);
TraceRegexp("sub {0}", tail);
}
public void EmitBalanceStart(int gid, int balance, bool capture, LinkRef tail)
{
BeginLink(tail);
Emit(RxOp.BalanceStart);
Emit((ushort)gid);
Emit((ushort)balance);
Emit((byte)(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 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 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 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 ResolveLink(LinkRef lref)
{
PatternLinkStack stack = (PatternLinkStack)lref;
while (stack.Pop())
{
pgm[stack.OffsetAddress] = (ushort)stack.GetOffset(CurrentAddress);
}
TraceRegexpLabel(lref);
}
public void EmitIfDefined(int gid, LinkRef tail)
{
if (gid > ushort.MaxValue)
{
throw new NotSupportedException();
}
BeginLink(tail);
Emit(RxOp.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);
TraceRegexp("balance start gid {0} balance {1} capture {2} tail {3}", gid, balance, capture, tail);
}
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);
}
}
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);
}
public void EmitSub(LinkRef tail)
{
BeginLink(tail);
Emit(RxOp.SubExpression);
EmitLink(tail);
}
public void EmitUntil(LinkRef repeat)
{
ResolveLink(repeat);
Emit(RxOp.Until);
}
void BeginLink(LinkRef lref)
{
RxLinkRef link = lref as RxLinkRef;
link.PushInstructionBase(curpos);
}
private void BeginLink(LinkRef lref)
{
PatternLinkStack stack = (PatternLinkStack)lref;
stack.BaseAddress = CurrentAddress;
}
public void EmitJump(LinkRef target)
{
BeginLink(target);
Emit(RxOp.Jump);
EmitLink(target);
}
static void TraceRegexpLabel(LinkRef lref)
{
Console.Write("{0}:", lref);
}
public void EmitBranch(LinkRef next)
{
BeginLink(next);
Emit(RxOp.Branch);
EmitLink(next);
}
