public virtual void Abort()
{
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
internal static Exception MethodNotImplemented([CallerMemberName] string methodName = "")
{
return(NotImplemented.ByDesignWithMessage(methodName));
}
public virtual WebResponse GetResponse()
{
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
public virtual IAsyncResult BeginGetRequestStream(AsyncCallback callback, object state)
{
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
/// Provides Internet Protocol (IP) statistical data for this network interface.
public virtual IPInterfaceStatistics GetIPStatistics()
{
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
public virtual bool Supports(NetworkInterfaceComponent networkInterfaceComponent)
{
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
public int SetContextAttributes(SafeDeleteContext context, Interop.SspiCli.ContextAttribute attribute, byte[] buffer)
{
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
public int VerifySignature(SafeDeleteContext context, ref Interop.SspiCli.SecBufferDesc inputOutput, uint sequenceNumber)
{
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
public async Task Time()
{
NotImplemented response = await crest.GetRoot().QueryAsync(r => r.Time);
}
/// <summary>
/// Returns IPv6 scope identifiers.
/// </summary>
/// <param name="scopeLevel">The scope level.</param>
/// <returns>The IPv6 scope identifier.</returns>
public virtual long GetScopeId(ScopeLevel scopeLevel)
{
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
public async Task Races()
{
NotImplemented response = await crest.GetRoot().QueryAsync(r => r.Races);
}
public async Task BattleTheatres()
{
NotImplemented response = await crest.GetRoot().QueryAsync(r => r.BattleTheatres);
}
public async Task Corporations()
{
NotImplemented response = await crest.GetRoot().QueryAsync(r => r.Corporations);
}
public async Task Channels()
{
NotImplemented response = await crest.GetRoot().QueryAsync(r => r.Channels);
}
private static bool TryParseSByteN(ReadOnlySpan <byte> text, out sbyte value, out int bytesConsumed)
{
throw NotImplemented.ActiveIssue("https://github.com/dotnet/corefx/issues/24986");
}
private unsafe static int EncryptDecryptHelper(OP op, SSPIInterface secModule, SafeDeleteContext context, SecurityBuffer[] input, uint sequenceNumber)
{
Interop.SspiCli.SecBufferDesc sdcInOut = new Interop.SspiCli.SecBufferDesc(input.Length);
var unmanagedBuffer = new Interop.SspiCli.SecBuffer[input.Length];
fixed(Interop.SspiCli.SecBuffer *unmanagedBufferPtr = unmanagedBuffer)
{
sdcInOut.pBuffers = unmanagedBufferPtr;
GCHandle[] pinnedBuffers = new GCHandle[input.Length];
byte[][] buffers = new byte[input.Length][];
try
{
for (int i = 0; i < input.Length; i++)
{
SecurityBuffer iBuffer = input[i];
unmanagedBuffer[i].cbBuffer = iBuffer.size;
unmanagedBuffer[i].BufferType = iBuffer.type;
if (iBuffer.token == null || iBuffer.token.Length == 0)
{
unmanagedBuffer[i].pvBuffer = IntPtr.Zero;
}
else
{
pinnedBuffers[i] = GCHandle.Alloc(iBuffer.token, GCHandleType.Pinned);
unmanagedBuffer[i].pvBuffer = Marshal.UnsafeAddrOfPinnedArrayElement(iBuffer.token, iBuffer.offset);
buffers[i] = iBuffer.token;
}
}
// The result is written in the input Buffer passed as type=BufferType.Data.
int errorCode;
switch (op)
{
case OP.Encrypt:
errorCode = secModule.EncryptMessage(context, sdcInOut, sequenceNumber);
break;
case OP.Decrypt:
errorCode = secModule.DecryptMessage(context, sdcInOut, sequenceNumber);
break;
case OP.MakeSignature:
errorCode = secModule.MakeSignature(context, sdcInOut, sequenceNumber);
break;
case OP.VerifySignature:
errorCode = secModule.VerifySignature(context, sdcInOut, sequenceNumber);
break;
default:
if (GlobalLog.IsEnabled)
{
GlobalLog.Assert("SSPIWrapper::EncryptDecryptHelper", "Unknown OP: " + op);
}
Debug.Fail("SSPIWrapper::EncryptDecryptHelper", "Unknown OP: " + op);
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
// Marshalling back returned sizes / data.
for (int i = 0; i < input.Length; i++)
{
SecurityBuffer iBuffer = input[i];
iBuffer.size = unmanagedBuffer[i].cbBuffer;
iBuffer.type = unmanagedBuffer[i].BufferType;
if (iBuffer.size == 0)
{
iBuffer.offset = 0;
iBuffer.token = null;
}
else
{
checked
{
// Find the buffer this is inside of. Usually they all point inside buffer 0.
int j;
for (j = 0; j < input.Length; j++)
{
if (buffers[j] == null)
{
continue;
}
byte *bufferAddress = (byte *)Marshal.UnsafeAddrOfPinnedArrayElement(buffers[j], 0);
if ((byte *)unmanagedBuffer[i].pvBuffer >= bufferAddress &&
(byte *)unmanagedBuffer[i].pvBuffer + iBuffer.size <= bufferAddress + buffers[j].Length)
{
iBuffer.offset = (int)((byte *)unmanagedBuffer[i].pvBuffer - bufferAddress);
iBuffer.token = buffers[j];
break;
}
}
if (j >= input.Length)
{
if (GlobalLog.IsEnabled)
{
GlobalLog.Assert("SSPIWrapper::EncryptDecryptHelper", "Output buffer out of range.");
}
Debug.Fail("SSPIWrapper::EncryptDecryptHelper", "Output buffer out of range.");
iBuffer.size = 0;
iBuffer.offset = 0;
iBuffer.token = null;
}
}
}
// Backup validate the new sizes.
if (iBuffer.offset < 0 || iBuffer.offset > (iBuffer.token == null ? 0 : iBuffer.token.Length))
{
if (GlobalLog.IsEnabled)
{
GlobalLog.AssertFormat("SSPIWrapper::EncryptDecryptHelper|'offset' out of range. [{0}]", iBuffer.offset);
}
Debug.Fail("SSPIWrapper::EncryptDecryptHelper|'offset' out of range. [" + iBuffer.offset + "]");
}
if (iBuffer.size < 0 || iBuffer.size > (iBuffer.token == null ? 0 : iBuffer.token.Length - iBuffer.offset))
{
if (GlobalLog.IsEnabled)
{
GlobalLog.AssertFormat("SSPIWrapper::EncryptDecryptHelper|'size' out of range. [{0}]", iBuffer.size);
}
Debug.Fail("SSPIWrapper::EncryptDecryptHelper|'size' out of range. [" + iBuffer.size + "]");
}
}
if (errorCode != 0 && NetEventSource.Log.IsEnabled())
{
if (errorCode == Interop.SspiCli.SEC_I_RENEGOTIATE)
{
NetEventSource.PrintError(NetEventSource.ComponentType.Security, SR.Format(SR.event_OperationReturnedSomething, op, "SEC_I_RENEGOTIATE"));
}
else
{
NetEventSource.PrintError(NetEventSource.ComponentType.Security, SR.Format(SR.net_log_operation_failed_with_error, op, String.Format(CultureInfo.CurrentCulture, "0X{0:X}", errorCode)));
}
}
return(errorCode);
}
finally
{
for (int i = 0; i < pinnedBuffers.Length; ++i)
{
if (pinnedBuffers[i].IsAllocated)
{
pinnedBuffers[i].Free();
}
}
}
}
}
public HttpClientHandler()
{
throw NotImplemented.ByDesignWithMessage("HTTP stack not implemented");
}
/// Gets the IP properties for this network interface.
public virtual IPInterfaceProperties GetIPProperties()
{
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
protected internal override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request,
CancellationToken cancellationToken)
{
throw NotImplemented.ByDesignWithMessage("HTTP stack not implemented");
}
/// Gets the physical address of this network interface
public virtual PhysicalAddress GetPhysicalAddress()
{
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
/// <summary>
/// Returns a list of all unicast IP addresses after ensuring they are all stable.
/// </summary>
/// <returns>The collection of unicast IP addresses.</returns>
public virtual Task <UnicastIPAddressInformationCollection> GetUnicastAddressesAsync()
{
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
public virtual Stream GetRequestStream()
{
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
public virtual IAsyncResult BeginGetUnicastAddresses(AsyncCallback?callback, object?state)
{
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
public virtual WebResponse EndGetResponse(IAsyncResult asyncResult)
{
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
public virtual UnicastIPAddressInformationCollection EndGetUnicastAddresses(IAsyncResult asyncResult)
{
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
public virtual Stream EndGetRequestStream(IAsyncResult asyncResult)
{
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
public static KFlyCommand Parse(List<Byte> bytes)
{
if (bytes.Count > 3)
{
KFlyCommand cmd = null;
switch ((KFlyCommandType)(bytes[1]))
{
case KFlyCommandType.DebugMessage:
cmd = new DebugMessage();
break;
case KFlyCommandType.Ping:
cmd = new Ping();
break;
case KFlyCommandType.GetDeviceInfo:
cmd = new GetDeviceInfo();
break;
case KFlyCommandType.GetSensorData:
cmd = new GetSensorData();
break;
case KFlyCommandType.GetEstimationAttitude:
cmd = new GetEstimationAttitude();
break;
case KFlyCommandType.GetRawSensorData:
cmd = new GetRawSensorData();
break;
case KFlyCommandType.GetRateControllerData:
cmd = new GetRateControllerData();
break;
case KFlyCommandType.GetAttitudeControllerData:
cmd = new GetAttitudeControllerData();
break;
case KFlyCommandType.GetSensorCalibration:
cmd = new GetSensorCalibration();
break;
case KFlyCommandType.GetChannelMix:
cmd = new GetChannelMix();
break;
case KFlyCommandType.GetRCCalibration:
cmd = new GetRCCalibration();
break;
case KFlyCommandType.GetRCValues:
cmd = new GetRCValues();
break;
case KFlyCommandType.GetArmSettings:
cmd = new GetArmSettings();
break;
case KFlyCommandType.ACK:
cmd = new Ack();
break;
default:
cmd = new NotImplemented((KFlyCommandType)(bytes[1]));
break;
}
if (cmd != null)
{
List<byte> data = bytes.GetRange(4, bytes.Count-4);
cmd.ParseData(data);
}
return cmd;
}
return null;
}
private static int QueryContextIssuerList(SafeDeleteContext securityContext, out Object issuerList)
{
// TODO (Issue #3362) To be implemented
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
public int MakeSignature(SafeDeleteContext context, Interop.SspiCli.SecurityBufferDescriptor inputOutput, uint sequenceNumber)
{
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
protected override void Go()
{
Goto(0);
int advance = -1;
for (; ;)
{
if (advance >= 0)
{
// https://github.com/dotnet/coreclr/pull/14850#issuecomment-342256447
// Single common Advance call to reduce method size; and single method inline point
Advance(advance);
advance = -1;
}
#if DEBUG
if (runmatch.Debug)
{
DumpState();
}
#endif
CheckTimeout();
switch (Operator())
{
case RegexCode.Stop:
return;
case RegexCode.Nothing:
break;
case RegexCode.Goto:
Goto(Operand(0));
continue;
case RegexCode.Testref:
if (!IsMatched(Operand(0)))
{
break;
}
advance = 1;
continue;
case RegexCode.Lazybranch:
TrackPush(Textpos());
advance = 1;
continue;
case RegexCode.Lazybranch | RegexCode.Back:
TrackPop();
Textto(TrackPeek());
Goto(Operand(0));
continue;
case RegexCode.Setmark:
StackPush(Textpos());
TrackPush();
advance = 0;
continue;
case RegexCode.Nullmark:
StackPush(-1);
TrackPush();
advance = 0;
continue;
case RegexCode.Setmark | RegexCode.Back:
case RegexCode.Nullmark | RegexCode.Back:
StackPop();
break;
case RegexCode.Getmark:
StackPop();
TrackPush(StackPeek());
Textto(StackPeek());
advance = 0;
continue;
case RegexCode.Getmark | RegexCode.Back:
TrackPop();
StackPush(TrackPeek());
break;
case RegexCode.Capturemark:
if (Operand(1) != -1 && !IsMatched(Operand(1)))
{
break;
}
StackPop();
if (Operand(1) != -1)
{
TransferCapture(Operand(0), Operand(1), StackPeek(), Textpos());
}
else
{
Capture(Operand(0), StackPeek(), Textpos());
}
TrackPush(StackPeek());
advance = 2;
continue;
case RegexCode.Capturemark | RegexCode.Back:
TrackPop();
StackPush(TrackPeek());
Uncapture();
if (Operand(0) != -1 && Operand(1) != -1)
{
Uncapture();
}
break;
case RegexCode.Branchmark:
{
int matched;
StackPop();
matched = Textpos() - StackPeek();
if (matched != 0)
{ // Nonempty match -> loop now
TrackPush(StackPeek(), Textpos()); // Save old mark, textpos
StackPush(Textpos()); // Make new mark
Goto(Operand(0)); // Loop
}
else
{ // Empty match -> straight now
TrackPush2(StackPeek()); // Save old mark
advance = 1; // Straight
}
continue;
}
case RegexCode.Branchmark | RegexCode.Back:
TrackPop(2);
StackPop();
Textto(TrackPeek(1)); // Recall position
TrackPush2(TrackPeek()); // Save old mark
advance = 1; // Straight
continue;
case RegexCode.Branchmark | RegexCode.Back2:
TrackPop();
StackPush(TrackPeek()); // Recall old mark
break; // Backtrack
case RegexCode.Lazybranchmark:
{
// We hit this the first time through a lazy loop and after each
// successful match of the inner expression. It simply continues
// on and doesn't loop.
StackPop();
int oldMarkPos = StackPeek();
if (Textpos() != oldMarkPos)
{ // Nonempty match -> try to loop again by going to 'back' state
if (oldMarkPos != -1)
{
TrackPush(oldMarkPos, Textpos()); // Save old mark, textpos
}
else
{
TrackPush(Textpos(), Textpos());
}
}
else
{
// The inner expression found an empty match, so we'll go directly to 'back2' if we
// backtrack. In this case, we need to push something on the stack, since back2 pops.
// However, in the case of ()+? or similar, this empty match may be legitimate, so push the text
// position associated with that empty match.
StackPush(oldMarkPos);
TrackPush2(StackPeek()); // Save old mark
}
advance = 1;
continue;
}
case RegexCode.Lazybranchmark | RegexCode.Back:
{
// After the first time, Lazybranchmark | RegexCode.Back occurs
// with each iteration of the loop, and therefore with every attempted
// match of the inner expression. We'll try to match the inner expression,
// then go back to Lazybranchmark if successful. If the inner expression
// fails, we go to Lazybranchmark | RegexCode.Back2
int pos;
TrackPop(2);
pos = TrackPeek(1);
TrackPush2(TrackPeek()); // Save old mark
StackPush(pos); // Make new mark
Textto(pos); // Recall position
Goto(Operand(0)); // Loop
continue;
}
case RegexCode.Lazybranchmark | RegexCode.Back2:
// The lazy loop has failed. We'll do a true backtrack and
// start over before the lazy loop.
StackPop();
TrackPop();
StackPush(TrackPeek()); // Recall old mark
break;
case RegexCode.Setcount:
StackPush(Textpos(), Operand(0));
TrackPush();
advance = 1;
continue;
case RegexCode.Nullcount:
StackPush(-1, Operand(0));
TrackPush();
advance = 1;
continue;
case RegexCode.Setcount | RegexCode.Back:
StackPop(2);
break;
case RegexCode.Nullcount | RegexCode.Back:
StackPop(2);
break;
case RegexCode.Branchcount:
// StackPush:
// 0: Mark
// 1: Count
{
StackPop(2);
int mark = StackPeek();
int count = StackPeek(1);
int matched = Textpos() - mark;
if (count >= Operand(1) || (matched == 0 && count >= 0))
{ // Max loops or empty match -> straight now
TrackPush2(mark, count); // Save old mark, count
advance = 2; // Straight
}
else
{ // Nonempty match -> count+loop now
TrackPush(mark); // remember mark
StackPush(Textpos(), count + 1); // Make new mark, incr count
Goto(Operand(0)); // Loop
}
continue;
}
case RegexCode.Branchcount | RegexCode.Back:
// TrackPush:
// 0: Previous mark
// StackPush:
// 0: Mark (= current pos, discarded)
// 1: Count
TrackPop();
StackPop(2);
if (StackPeek(1) > 0)
{ // Positive -> can go straight
Textto(StackPeek()); // Zap to mark
TrackPush2(TrackPeek(), StackPeek(1) - 1); // Save old mark, old count
advance = 2; // Straight
continue;
}
StackPush(TrackPeek(), StackPeek(1) - 1); // recall old mark, old count
break;
case RegexCode.Branchcount | RegexCode.Back2:
// TrackPush:
// 0: Previous mark
// 1: Previous count
TrackPop(2);
StackPush(TrackPeek(), TrackPeek(1)); // Recall old mark, old count
break; // Backtrack
case RegexCode.Lazybranchcount:
// StackPush:
// 0: Mark
// 1: Count
{
StackPop(2);
int mark = StackPeek();
int count = StackPeek(1);
if (count < 0)
{ // Negative count -> loop now
TrackPush2(mark); // Save old mark
StackPush(Textpos(), count + 1); // Make new mark, incr count
Goto(Operand(0)); // Loop
}
else
{ // Nonneg count -> straight now
TrackPush(mark, count, Textpos()); // Save mark, count, position
advance = 2; // Straight
}
continue;
}
case RegexCode.Lazybranchcount | RegexCode.Back:
// TrackPush:
// 0: Mark
// 1: Count
// 2: Textpos
{
TrackPop(3);
int mark = TrackPeek();
int textpos = TrackPeek(2);
if (TrackPeek(1) < Operand(1) && textpos != mark)
{ // Under limit and not empty match -> loop
Textto(textpos); // Recall position
StackPush(textpos, TrackPeek(1) + 1); // Make new mark, incr count
TrackPush2(mark); // Save old mark
Goto(Operand(0)); // Loop
continue;
}
else
{ // Max loops or empty match -> backtrack
StackPush(TrackPeek(), TrackPeek(1)); // Recall old mark, count
break; // backtrack
}
}
case RegexCode.Lazybranchcount | RegexCode.Back2:
// TrackPush:
// 0: Previous mark
// StackPush:
// 0: Mark (== current pos, discarded)
// 1: Count
TrackPop();
StackPop(2);
StackPush(TrackPeek(), StackPeek(1) - 1); // Recall old mark, count
break; // Backtrack
case RegexCode.Setjump:
StackPush(Trackpos(), Crawlpos());
TrackPush();
advance = 0;
continue;
case RegexCode.Setjump | RegexCode.Back:
StackPop(2);
break;
case RegexCode.Backjump:
// StackPush:
// 0: Saved trackpos
// 1: Crawlpos
StackPop(2);
Trackto(StackPeek());
while (Crawlpos() != StackPeek(1))
{
Uncapture();
}
break;
case RegexCode.Forejump:
// StackPush:
// 0: Saved trackpos
// 1: Crawlpos
StackPop(2);
Trackto(StackPeek());
TrackPush(StackPeek(1));
advance = 0;
continue;
case RegexCode.Forejump | RegexCode.Back:
// TrackPush:
// 0: Crawlpos
TrackPop();
while (Crawlpos() != TrackPeek())
{
Uncapture();
}
break;
case RegexCode.Bol:
if (Leftchars() > 0 && CharAt(Textpos() - 1) != '\n')
{
break;
}
advance = 0;
continue;
case RegexCode.Eol:
if (Rightchars() > 0 && CharAt(Textpos()) != '\n')
{
break;
}
advance = 0;
continue;
case RegexCode.Boundary:
if (!IsBoundary(Textpos(), runtextbeg, runtextend))
{
break;
}
advance = 0;
continue;
case RegexCode.Nonboundary:
if (IsBoundary(Textpos(), runtextbeg, runtextend))
{
break;
}
advance = 0;
continue;
case RegexCode.ECMABoundary:
if (!IsECMABoundary(Textpos(), runtextbeg, runtextend))
{
break;
}
advance = 0;
continue;
case RegexCode.NonECMABoundary:
if (IsECMABoundary(Textpos(), runtextbeg, runtextend))
{
break;
}
advance = 0;
continue;
case RegexCode.Beginning:
if (Leftchars() > 0)
{
break;
}
advance = 0;
continue;
case RegexCode.Start:
if (Textpos() != Textstart())
{
break;
}
advance = 0;
continue;
case RegexCode.EndZ:
if (Rightchars() > 1 || Rightchars() == 1 && CharAt(Textpos()) != '\n')
{
break;
}
advance = 0;
continue;
case RegexCode.End:
if (Rightchars() > 0)
{
break;
}
advance = 0;
continue;
case RegexCode.One:
if (Forwardchars() < 1 || Forwardcharnext() != (char)Operand(0))
{
break;
}
advance = 1;
continue;
case RegexCode.Notone:
if (Forwardchars() < 1 || Forwardcharnext() == (char)Operand(0))
{
break;
}
advance = 1;
continue;
case RegexCode.Set:
if (Forwardchars() < 1 || !RegexCharClass.CharInClass(Forwardcharnext(), _code.Strings[Operand(0)]))
{
break;
}
advance = 1;
continue;
case RegexCode.Multi:
{
if (!Stringmatch(_code.Strings[Operand(0)]))
{
break;
}
advance = 1;
continue;
}
case RegexCode.Ref:
{
int capnum = Operand(0);
if (IsMatched(capnum))
{
if (!Refmatch(MatchIndex(capnum), MatchLength(capnum)))
{
break;
}
}
else
{
if ((runregex.roptions & RegexOptions.ECMAScript) == 0)
{
break;
}
}
advance = 1;
continue;
}
case RegexCode.Onerep:
{
int c = Operand(1);
if (Forwardchars() < c)
{
break;
}
char ch = (char)Operand(0);
while (c-- > 0)
{
if (Forwardcharnext() != ch)
{
goto BreakBackward;
}
}
advance = 2;
continue;
}
case RegexCode.Notonerep:
{
int c = Operand(1);
if (Forwardchars() < c)
{
break;
}
char ch = (char)Operand(0);
while (c-- > 0)
{
if (Forwardcharnext() == ch)
{
goto BreakBackward;
}
}
advance = 2;
continue;
}
case RegexCode.Setrep:
{
int c = Operand(1);
if (Forwardchars() < c)
{
break;
}
string set = _code.Strings[Operand(0)];
while (c-- > 0)
{
if (!RegexCharClass.CharInClass(Forwardcharnext(), set))
{
goto BreakBackward;
}
}
advance = 2;
continue;
}
case RegexCode.Oneloop:
{
int c = Operand(1);
if (c > Forwardchars())
{
c = Forwardchars();
}
char ch = (char)Operand(0);
int i;
for (i = c; i > 0; i--)
{
if (Forwardcharnext() != ch)
{
Backwardnext();
break;
}
}
if (c > i)
{
TrackPush(c - i - 1, Textpos() - Bump());
}
advance = 2;
continue;
}
case RegexCode.Notoneloop:
{
int c = Operand(1);
if (c > Forwardchars())
{
c = Forwardchars();
}
char ch = (char)Operand(0);
int i;
for (i = c; i > 0; i--)
{
if (Forwardcharnext() == ch)
{
Backwardnext();
break;
}
}
if (c > i)
{
TrackPush(c - i - 1, Textpos() - Bump());
}
advance = 2;
continue;
}
case RegexCode.Setloop:
{
int c = Operand(1);
if (c > Forwardchars())
{
c = Forwardchars();
}
string set = _code.Strings[Operand(0)];
int i;
for (i = c; i > 0; i--)
{
if (!RegexCharClass.CharInClass(Forwardcharnext(), set))
{
Backwardnext();
break;
}
}
if (c > i)
{
TrackPush(c - i - 1, Textpos() - Bump());
}
advance = 2;
continue;
}
case RegexCode.Oneloop | RegexCode.Back:
case RegexCode.Notoneloop | RegexCode.Back:
{
TrackPop(2);
int i = TrackPeek();
int pos = TrackPeek(1);
Textto(pos);
if (i > 0)
{
TrackPush(i - 1, pos - Bump());
}
advance = 2;
continue;
}
case RegexCode.Setloop | RegexCode.Back:
{
TrackPop(2);
int i = TrackPeek();
int pos = TrackPeek(1);
Textto(pos);
if (i > 0)
{
TrackPush(i - 1, pos - Bump());
}
advance = 2;
continue;
}
case RegexCode.Onelazy:
case RegexCode.Notonelazy:
{
int c = Operand(1);
if (c > Forwardchars())
{
c = Forwardchars();
}
if (c > 0)
{
TrackPush(c - 1, Textpos());
}
advance = 2;
continue;
}
case RegexCode.Setlazy:
{
int c = Operand(1);
if (c > Forwardchars())
{
c = Forwardchars();
}
if (c > 0)
{
TrackPush(c - 1, Textpos());
}
advance = 2;
continue;
}
case RegexCode.Onelazy | RegexCode.Back:
{
TrackPop(2);
int pos = TrackPeek(1);
Textto(pos);
if (Forwardcharnext() != (char)Operand(0))
{
break;
}
int i = TrackPeek();
if (i > 0)
{
TrackPush(i - 1, pos + Bump());
}
advance = 2;
continue;
}
case RegexCode.Notonelazy | RegexCode.Back:
{
TrackPop(2);
int pos = TrackPeek(1);
Textto(pos);
if (Forwardcharnext() == (char)Operand(0))
{
break;
}
int i = TrackPeek();
if (i > 0)
{
TrackPush(i - 1, pos + Bump());
}
advance = 2;
continue;
}
case RegexCode.Setlazy | RegexCode.Back:
{
TrackPop(2);
int pos = TrackPeek(1);
Textto(pos);
if (!RegexCharClass.CharInClass(Forwardcharnext(), _code.Strings[Operand(0)]))
{
break;
}
int i = TrackPeek();
if (i > 0)
{
TrackPush(i - 1, pos + Bump());
}
advance = 2;
continue;
}
default:
throw NotImplemented.ByDesignWithMessage(SR.UnimplementedState);
}
BreakBackward:
;
// "break Backward" comes here:
Backtrack();
}
}
/// <devdoc>
/// <para>
/// Creates an EndPoint instance from a SocketAddress structure.
/// </para>
/// </devdoc>
public virtual EndPoint Create(SocketAddress socketAddress)
{
throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
