//-------------------------------------------------------------------------------------------------------

// Copyright (C) Microsoft. All rights reserved.

// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.

//-------------------------------------------------------------------------------------------------------

#include "ParserPch.h"

namespace UnifiedRegex

{

// ----------------------------------------------------------------------

// CountDomain

// ----------------------------------------------------------------------

#if ENABLE_REGEX_CONFIG_OPTIONS

void CountDomain::Print(DebugWriter* w) const

{

if (upper != CharCountFlag && lower == (CharCount)upper)

w->Print(_u("[%u]"), lower);

else

{

w->Print(_u("[%u-"), lower);

if (upper == CharCountFlag)

w->Print(_u("inf]"));

else

w->Print(_u("%u]"), (CharCount)upper);

}

}

#endif

// ----------------------------------------------------------------------

// Matcher (inlined, called from instruction Exec methods)

// ----------------------------------------------------------------------

#define PUSH(contStack, T, ...) (new (contStack.Push<T>()) T(__VA_ARGS__))

#define PUSHA(assertionStack, T, ...) (new (assertionStack.Push()) T(__VA_ARGS__))

#define L2I(O, label) LabelToInstPointer<O##Inst>(Inst::O, label)

#define FAIL_PARAMETERS input, inputOffset, instPointer, contStack, assertionStack, qcTicks

#define HARDFAIL_PARAMETERS(mode) input, inputLength, matchStart, inputOffset, instPointer, contStack, assertionStack, qcTicks, mode

// Regex QC heuristics:

// - TicksPerQC

// - Number of ticks from a previous QC needed to cause another QC. The value affects how often QC will be triggered, so

// on slower machines or debug builds, the value needs to be smaller to maintain a reasonable frequency of QCs.

// - TicksPerQcTimeCheck

// - Number of ticks from a previous QC needed to trigger a time check. Elapsed time from the previous QC is checked to

// see if a QC needs to be triggered. The value must be less than TicksPerQc and small enough to reasonably guarantee

// a QC every TimePerQc milliseconds without affecting perf.

// - TimePerQc

// - The target time between QCs

#if defined(_M_ARM)

const uint Matcher::TicksPerQc = 1u << 19

#else

const uint Matcher::TicksPerQc = 1u << (AutoSystemInfo::ShouldQCMoreFrequently() ? 17 : 21)

#endif

#if DBG

>> 2

#endif

;

const uint Matcher::TicksPerQcTimeCheck = Matcher::TicksPerQc >> 2;

const uint Matcher::TimePerQc = AutoSystemInfo::ShouldQCMoreFrequently() ? 50 : 100; // milliseconds

#if ENABLE_REGEX_CONFIG_OPTIONS

void Matcher::PushStats(ContStack& contStack, const Char* const input) const

{

if (stats != 0)

{

stats->numPushes++;

if (contStack.Position() > stats->stackHWM)

stats->stackHWM = contStack.Position();

}

if (w != 0)

{

w->Print(_u("PUSH "));

contStack.Top()->Print(w, input);

}

}

void Matcher::PopStats(ContStack& contStack, const Char* const input) const

{

if (stats != 0)

stats->numPops++;

if (w != 0)

{

const Cont* top = contStack.Top();

if (top == 0)

w->PrintEOL(_u("<empty stack>"));

else

{

w->Print(_u("POP "));

top->Print(w, input);

}

}

}

void Matcher::UnPopStats(ContStack& contStack, const Char* const input) const

{

if (stats != 0)

stats->numPops--;

if (w != 0)

{

const Cont* top = contStack.Top();

if (top == 0)

w->PrintEOL(_u("<empty stack>"));

else

{

w->Print(_u("UNPOP "));

top->Print(w, input);

}

}

}

void Matcher::CompStats() const

{

if (stats != 0)

stats->numCompares++;

}

void Matcher::InstStats() const

{

if (stats != 0)

stats->numInsts++;

}

#endif

inline void Matcher::QueryContinue(uint &qcTicks)

{

// See definition of TimePerQc for description of regex QC heuristics

Assert(!(TicksPerQc & TicksPerQc - 1)); // must be a power of 2

Assert(!(TicksPerQcTimeCheck & TicksPerQcTimeCheck - 1)); // must be a power of 2

Assert(TicksPerQcTimeCheck < TicksPerQc);

if(PHASE_OFF1(Js::RegexQcPhase))

return;

if(++qcTicks & TicksPerQcTimeCheck - 1)

return;

DoQueryContinue(qcTicks);

}

inline bool Matcher::HardFail

( const Char* const input

, const CharCount inputLength

, CharCount &matchStart

, CharCount &inputOffset

, const uint8 *&instPointer

, ContStack &contStack

, AssertionStack &assertionStack

, uint &qcTicks

, HardFailMode mode )

{

switch (mode)

{

case BacktrackAndLater:

return Fail(FAIL_PARAMETERS);

case BacktrackOnly:

if (Fail(FAIL_PARAMETERS))

{

// No use trying any more start positions

matchStart = inputLength;

return true; // STOP EXECUTING

}

else

return false;

case LaterOnly:

#if ENABLE_REGEX_CONFIG_OPTIONS

if (w != 0)

w->PrintEOL(_u("CLEAR"));

#endif

contStack.Clear();

assertionStack.Clear();

return true; // STOP EXECUTING

case ImmediateFail:

// No use trying any more start positions

matchStart = inputLength;

return true; // STOP EXECUTING

default:

Assume(false);

}

return true;

}

inline bool Matcher::PopAssertion(CharCount &inputOffset, const uint8 *&instPointer, ContStack &contStack, AssertionStack &assertionStack, bool succeeded)

{

AssertionInfo* info = assertionStack.Top();

Assert(info != 0);

assertionStack.Pop();

BeginAssertionInst* begin = L2I(BeginAssertion, info->beginLabel);

// Cut the existing continuations (we never backtrack into an assertion)

// NOTE: We don't include the effective pops in the stats

#if ENABLE_REGEX_CONFIG_OPTIONS

if (w != 0)

w->PrintEOL(_u("POP TO %llu"), (unsigned long long)info->contStackPosition);

#endif

contStack.PopTo(info->contStackPosition);

// succeeded isNegation action

// --------- ---------- ----------------------------------------------------------------------------------

// false false Fail into outer continuations (inner group bindings will have been undone)

// true false Jump to next label (inner group bindings are now frozen)

// false true Jump to next label (inner group bindings will have been undone and are now frozen)

// true true Fail into outer continuations (inner group binding MUST BE CLEARED)

if (succeeded && begin->isNegation)

ResetInnerGroups(begin->minBodyGroupId, begin->maxBodyGroupId);

if (succeeded == begin->isNegation)

{

// Assertion failed

return false;

}

else

{

// Continue with next label but from original input position

inputOffset = info->startInputOffset;

instPointer = LabelToInstPointer(begin->nextLabel);

return true;

}

}

inline void Matcher::SaveInnerGroups(

const int fromGroupId,

const int toGroupId,

const bool reset,

const Char *const input,

ContStack &contStack)

{

if(toGroupId >= 0)

DoSaveInnerGroups(fromGroupId, toGroupId, reset, input, contStack);

}

void Matcher::DoSaveInnerGroups(

const int fromGroupId,

const int toGroupId,

const bool reset,

const Char *const input,

ContStack &contStack)

{

Assert(fromGroupId >= 0);

Assert(toGroupId >= 0);

Assert(fromGroupId <= toGroupId);

int undefinedRangeFromId = -1;

int groupId = fromGroupId;

do

{

GroupInfo *const groupInfo = GroupIdToGroupInfo(groupId);

if(groupInfo->IsUndefined())

{

if(undefinedRangeFromId < 0)

undefinedRangeFromId = groupId;

continue;

}

if(undefinedRangeFromId >= 0)

{

Assert(groupId > 0);

DoSaveInnerGroups_AllUndefined(undefinedRangeFromId, groupId - 1, input, contStack);

undefinedRangeFromId = -1;

}

PUSH(contStack, RestoreGroupCont, groupId, *groupInfo);

#if ENABLE_REGEX_CONFIG_OPTIONS

PushStats(contStack, input);

#endif

if(reset)

groupInfo->Reset();

} while(++groupId <= toGroupId);

if(undefinedRangeFromId >= 0)

{

Assert(toGroupId >= 0);

DoSaveInnerGroups_AllUndefined(undefinedRangeFromId, toGroupId, input, contStack);

}

}

inline void Matcher::SaveInnerGroups_AllUndefined(

const int fromGroupId,

const int toGroupId,

const Char *const input,

ContStack &contStack)

{

if(toGroupId >= 0)

DoSaveInnerGroups_AllUndefined(fromGroupId, toGroupId, input, contStack);

}

void Matcher::DoSaveInnerGroups_AllUndefined(

const int fromGroupId,

const int toGroupId,

const Char *const input,

ContStack &contStack)

{

Assert(fromGroupId >= 0);

Assert(toGroupId >= 0);

Assert(fromGroupId <= toGroupId);

#if DBG

for(int groupId = fromGroupId; groupId <= toGroupId; ++groupId)

{

Assert(GroupIdToGroupInfo(groupId)->IsUndefined());

}

#endif

if(fromGroupId == toGroupId)

PUSH(contStack, ResetGroupCont, fromGroupId);

else

PUSH(contStack, ResetGroupRangeCont, fromGroupId, toGroupId);

#if ENABLE_REGEX_CONFIG_OPTIONS

PushStats(contStack, input);

#endif

}

inline void Matcher::ResetGroup(int groupId)

{

GroupInfo* info = GroupIdToGroupInfo(groupId);

info->Reset();

}

inline void Matcher::ResetInnerGroups(int minGroupId, int maxGroupId)

{

for (int i = minGroupId; i <= maxGroupId; i++)

ResetGroup(i);

}

#if ENABLE_REGEX_CONFIG_OPTIONS

bool Inst::IsBaselineMode()

{

return Js::Configuration::Global.flags.BaselineMode;

}

Label Inst::GetPrintLabel(Label label)

{

return IsBaselineMode() ? (Label)0xFFFF : label;

}

#endif

// ----------------------------------------------------------------------

// Mixins

// ----------------------------------------------------------------------

#if ENABLE_REGEX_CONFIG_OPTIONS

void BackupMixin::Print(DebugWriter* w, const char16* litbuf) const

{

w->Print(_u("backup: "));

backup.Print(w);

}

#endif

#if ENABLE_REGEX_CONFIG_OPTIONS

void CharMixin::Print(DebugWriter* w, const char16* litbuf) const

{

w->Print(_u("c: "));

w->PrintQuotedChar(c);

}

#endif

#if ENABLE_REGEX_CONFIG_OPTIONS

void Char2Mixin::Print(DebugWriter* w, const char16* litbuf) const

{

w->Print(_u("c0: "));

w->PrintQuotedChar(cs[0]);

w->Print(_u(", c1: "));

w->PrintQuotedChar(cs[1]);

}

#endif

#if ENABLE_REGEX_CONFIG_OPTIONS

void Char3Mixin::Print(DebugWriter* w, const char16* litbuf) const

{

w->Print(_u("c0: "));

w->PrintQuotedChar(cs[0]);

w->Print(_u(", c1: "));

w->PrintQuotedChar(cs[1]);

w->Print(_u(", c2: "));

w->PrintQuotedChar(cs[2]);

}

#endif

#if ENABLE_REGEX_CONFIG_OPTIONS

void Char4Mixin::Print(DebugWriter* w, const char16* litbuf) const

{

w->Print(_u("c0: "));

w->PrintQuotedChar(cs[0]);

w->Print(_u(", c1: "));

w->PrintQuotedChar(cs[1]);

w->Print(_u(", c2: "));

w->PrintQuotedChar(cs[2]);

w->Print(_u(", c3: "));

w->PrintQuotedChar(cs[3]);

}

#endif

#if ENABLE_REGEX_CONFIG_OPTIONS

void LiteralMixin::Print(DebugWriter* w, const char16* litbuf, bool isEquivClass) const

{

if (isEquivClass)

{

w->Print(_u("equivLiterals: "));

for (int i = 0; i < CaseInsensitive::EquivClassSize; i++)

{

if (i > 0)

w->Print(_u(", "));

w->Print(_u("\""));

for (CharCount j = 0; j < length; j++)

w->PrintEscapedChar(litbuf[offset + j * CaseInsensitive::EquivClassSize + i]);

w->Print(_u("\""));

}

}

else

{

w->Print(_u("literal: "));

w->PrintQuotedString(litbuf + offset, length);

}

}

#endif

// ----------------------------------------------------------------------

// Char2LiteralScannerMixin

// ----------------------------------------------------------------------

bool Char2LiteralScannerMixin::Match(Matcher& matcher, const char16* const input, const CharCount inputLength, CharCount& inputOffset) const

{

if (inputLength == 0)

{

return false;

}

const uint matchC0 = Chars<char16>::CTU(cs[0]);

const uint matchC1 = Chars<char16>::CTU(cs[1]);

const char16 * currentInput = input + inputOffset;

const char16 * endInput = input + inputLength - 1;

while (currentInput < endInput)

{

#if ENABLE_REGEX_CONFIG_OPTIONS

matcher.CompStats();

#endif

while (true)

{

const uint c1 = Chars<char16>::CTU(currentInput[1]);

if (c1 != matchC1)

{

if (c1 == matchC0)

{

break;

}

currentInput += 2;

if (currentInput >= endInput)

{

return false;

}

continue;

}

#if ENABLE_REGEX_CONFIG_OPTIONS

matcher.CompStats();

#endif

// Check the first character

const uint c0 = Chars<char16>::CTU(*currentInput);

if (c0 == matchC0)

{

inputOffset = (CharCount)(currentInput - input);

return true;

}

if (matchC0 == matchC1)

{

break;

}

currentInput +=2;

if (currentInput >= endInput)

{

return false;

}

}

// If the second character in the buffer matches the first in the pattern, continue

// to see if the next character has the second in the pattern

currentInput++;

while (currentInput < endInput)

{

#if ENABLE_REGEX_CONFIG_OPTIONS

matcher.CompStats();

#endif

const uint c1 = Chars<char16>::CTU(currentInput[1]);

if (c1 == matchC1)

{

inputOffset = (CharCount)(currentInput - input);

return true;

}

if (c1 != matchC0)

{

currentInput += 2;

break;

}

currentInput++;

}

}

return false;

}

#if ENABLE_REGEX_CONFIG_OPTIONS

void Char2LiteralScannerMixin::Print(DebugWriter* w, const char16 * litbuf) const

{

Char2Mixin::Print(w, litbuf);

w->Print(_u(" (with two character literal scanner)"));

}

#endif

// ----------------------------------------------------------------------

// ScannerMixinT

// ----------------------------------------------------------------------

template <typename ScannerT>

void ScannerMixinT<ScannerT>::FreeBody(ArenaAllocator* rtAllocator)

{

scanner.FreeBody(rtAllocator, length);

}

template <typename ScannerT>

inline bool

ScannerMixinT<ScannerT>::Match(Matcher& matcher, const char16 * const input, const CharCount inputLength, CharCount& inputOffset) const

{

Assert(length <= matcher.program->rep.insts.litbufLen - offset);

return scanner.template Match<1>

( input

, inputLength

, inputOffset

, matcher.program->rep.insts.litbuf + offset

, length

#if ENABLE_REGEX_CONFIG_OPTIONS

, matcher.stats

#endif

);

}

#if ENABLE_REGEX_CONFIG_OPTIONS

template <typename ScannerT>

void ScannerMixinT<ScannerT>::Print(DebugWriter* w, const char16* litbuf, bool isEquivClass) const

{

LiteralMixin::Print(w, litbuf, isEquivClass);

w->Print(_u(" (with %s scanner)"), ScannerT::GetName());

}

#endif

// explicit instantiation

template struct ScannerMixinT<TextbookBoyerMoore<char16>>;

template struct ScannerMixinT<TextbookBoyerMooreWithLinearMap<char16>>;

// ----------------------------------------------------------------------

// EquivScannerMixinT

// ----------------------------------------------------------------------

template <uint lastPatCharEquivClassSize>

inline bool EquivScannerMixinT<lastPatCharEquivClassSize>::Match(Matcher& matcher, const char16* const input, const CharCount inputLength, CharCount& inputOffset) const

{

Assert(length * CaseInsensitive::EquivClassSize <= matcher.program->rep.insts.litbufLen - offset);

CompileAssert(lastPatCharEquivClassSize >= 1 && lastPatCharEquivClassSize <= CaseInsensitive::EquivClassSize);

return scanner.Match<CaseInsensitive::EquivClassSize, lastPatCharEquivClassSize>

( input

, inputLength

, inputOffset

, matcher.program->rep.insts.litbuf + offset

, length

#if ENABLE_REGEX_CONFIG_OPTIONS

, matcher.stats

#endif

);

}

#if ENABLE_REGEX_CONFIG_OPTIONS

template <uint lastPatCharEquivClassSize>

void EquivScannerMixinT<lastPatCharEquivClassSize>::Print(DebugWriter* w, const char16* litbuf) const

{

__super::Print(w, litbuf, true);

w->Print(_u(" (last char equiv size:%d)"), lastPatCharEquivClassSize);

}

// explicit instantiation

template struct EquivScannerMixinT<1>;

#endif

// ----------------------------------------------------------------------

// ScannerInfo

// ----------------------------------------------------------------------

#if ENABLE_REGEX_CONFIG_OPTIONS

void ScannerInfo::Print(DebugWriter* w, const char16* litbuf) const

{

ScannerMixin::Print(w, litbuf, isEquivClass);

}

#endif

ScannerInfo* ScannersMixin::Add(Recycler *recycler, Program *program, CharCount offset, CharCount length, bool isEquivClass)

{

Assert(numLiterals < MaxNumSyncLiterals);

return program->AddScannerForSyncToLiterals(recycler, numLiterals++, offset, length, isEquivClass);

}

void ScannersMixin::FreeBody(ArenaAllocator* rtAllocator)

{

for (int i = 0; i < numLiterals; i++)

{

infos[i]->FreeBody(rtAllocator);

#if DBG

infos[i] = 0;

#endif

}

#if DBG

numLiterals = 0;

#endif

}

#if ENABLE_REGEX_CONFIG_OPTIONS

void ScannersMixin::Print(DebugWriter* w, const char16* litbuf) const

{

w->Print(_u("literals: {"));

for (int i = 0; i < numLiterals; i++)

{

if (i > 0)

w->Print(_u(", "));

infos[i]->Print(w, litbuf);

}

w->Print(_u("}"));

}

#endif

template<bool IsNegation>

void SetMixin<IsNegation>::FreeBody(ArenaAllocator* rtAllocator)

{

set.FreeBody(rtAllocator);

}

#if ENABLE_REGEX_CONFIG_OPTIONS

template<bool IsNegation>

void SetMixin<IsNegation>::Print(DebugWriter* w, const char16* litbuf) const

{

w->Print(_u("set: "));

if (IsNegation)

w->Print(_u("not "));

set.Print(w);

}

#endif

#if ENABLE_REGEX_CONFIG_OPTIONS

void HardFailMixin::Print(DebugWriter* w, const char16* litbuf) const

{

w->Print(_u("hardFail: %s"), canHardFail ? _u("true") : _u("false"));

}

#endif

#if ENABLE_REGEX_CONFIG_OPTIONS

void GroupMixin::Print(DebugWriter* w, const char16* litbuf) const

{

w->Print(_u("groupId: %d"), groupId);

}

#endif

#if ENABLE_REGEX_CONFIG_OPTIONS

void ChompBoundedMixin::Print(DebugWriter* w, const char16* litbuf) const

{

w->Print(_u("repeats: "));

repeats.Print(w);

}

#endif

#if ENABLE_REGEX_CONFIG_OPTIONS

void JumpMixin::Print(DebugWriter* w, const char16* litbuf) const

{

w->Print(_u("targetLabel: L%04x"), Inst::GetPrintLabel(targetLabel));

}

#endif

#if ENABLE_REGEX_CONFIG_OPTIONS

void BodyGroupsMixin::Print(DebugWriter* w, const char16* litbuf) const

{

w->Print(_u("minBodyGroupId: %d, maxBodyGroupId: %d"), minBodyGroupId, maxBodyGroupId);

}

#endif

#if ENABLE_REGEX_CONFIG_OPTIONS

void BeginLoopMixin::Print(DebugWriter* w, const char16* litbuf) const

{

w->Print(_u("loopId: %d, repeats: "), loopId);

repeats.Print(w);

w->Print(_u(", exitLabel: L%04x, hasOuterLoops: %s, hasInnerNondet: %s"),

Inst::GetPrintLabel(exitLabel), hasOuterLoops ? _u("true") : _u("false"), hasInnerNondet ? _u("true") : _u("false"));

}

#endif

#if ENABLE_REGEX_CONFIG_OPTIONS

void RepeatLoopMixin::Print(DebugWriter* w, const char16* litbuf) const

{

w->Print(_u("beginLabel: L%04x"), Inst::GetPrintLabel(beginLabel));

}

#endif

#if ENABLE_REGEX_CONFIG_OPTIONS

void TryMixin::Print(DebugWriter* w, const char16* litbuf) const

{

w->Print(_u("failLabel: L%04x"), Inst::GetPrintLabel(failLabel));

}

#endif

#if ENABLE_REGEX_CONFIG_OPTIONS

void FixedLengthMixin::Print(DebugWriter* w, const char16* litbuf) const

{

w->Print(_u("length: %u"), length);

}

#endif

#if ENABLE_REGEX_CONFIG_OPTIONS

void NoNeedToSaveMixin::Print(DebugWriter* w, const char16* litbuf) const

{

w->Print(_u("noNeedToSave: %s"), noNeedToSave ? _u("true") : _u("false"));

}

#endif

#if ENABLE_REGEX_CONFIG_OPTIONS

void SwitchCase::Print(DebugWriter* w) const

{

w->Print(_u("case "));

w->PrintQuotedChar(c);

w->PrintEOL(_u(": Jump(L%04x)"), targetLabel);

}

#endif

template <int n>

void SwitchMixin<n>::AddCase(char16 c, Label targetLabel)

{

Assert(numCases < MaxCases);

int i;

__analysis_assume(numCases < MaxCases);

for (i = 0; i < numCases; i++)

{

Assert(cases[i].c != c);

if (cases[i].c > c)

break;

}

__analysis_assume(numCases < MaxCases);

for (int j = numCases; j > i; j--)

cases[j] = cases[j - 1];

cases[i].c = c;

cases[i].targetLabel = targetLabel;

numCases++;

}

void UnifiedRegexSwitchMixinForceAllInstantiations()

{

{

SwitchMixin<10> x;

x.AddCase(0, 0);

#if ENABLE_REGEX_CONFIG_OPTIONS

x.Print(0, 0);

#endif

}

{

SwitchMixin<20> x;

x.AddCase(0, 0);

#if ENABLE_REGEX_CONFIG_OPTIONS

x.Print(0, 0);

#endif

}

}

#if ENABLE_REGEX_CONFIG_OPTIONS

template <int n>

void SwitchMixin<n>::Print(DebugWriter* w, const char16* litbuf) const

{

w->EOL();

w->Indent();

for (int i = 0; i < numCases; i++)

cases[i].Print(w);

w->Unindent();

}

#endif

// ----------------------------------------------------------------------

// FailInst

// ----------------------------------------------------------------------

inline bool FailInst::Exec(REGEX_INST_EXEC_PARAMETERS) const

{

return matcher.Fail(FAIL_PARAMETERS);

}

#if ENABLE_REGEX_CONFIG_OPTIONS

int FailInst::Print(DebugWriter* w, Label label, const Char* litbuf) const

{

w->PrintEOL(_u("L%04x: Fail()"), label);

return sizeof(*this);

}

#endif

// ----------------------------------------------------------------------

// SuccInst

// ----------------------------------------------------------------------

inline bool SuccInst::Exec(REGEX_INST_EXEC_PARAMETERS) const

{

GroupInfo* info = matcher.GroupIdToGroupInfo(0);

info->offset = matchStart;

info->length = inputOffset - matchStart;

return true; // STOP MATCHING

}

#if ENABLE_REGEX_CONFIG_OPTIONS

int SuccInst::Print(DebugWriter* w, Label label, const Char* litbuf) const

{

w->PrintEOL(_u("L%04x: Succ()"), label);

return sizeof(*this);

}

#endif

// ----------------------------------------------------------------------

// JumpInst

// ----------------------------------------------------------------------

inline bool JumpInst::Exec(REGEX_INST_EXEC_PARAMETERS) const

{

instPointer = matcher.LabelToInstPointer(targetLabel);

return false;

}

#if ENABLE_REGEX_CONFIG_OPTIONS

int JumpInst::Print(DebugWriter* w, Label label, const Char* litbuf) const

{

w->Print(_u("L%04x: Jump("), label);

JumpMixin::Print(w, litbuf);

w->PrintEOL(_u(")"));

return sizeof(*this);

}

#endif

// ----------------------------------------------------------------------

// JumpIfNotCharInst (optimized instruction)

// ----------------------------------------------------------------------

inline bool JumpIfNotCharInst::Exec(REGEX_INST_EXEC_PARAMETERS) const

{

#if ENABLE_REGEX_CONFIG_OPTIONS

matcher.CompStats();

#endif

if (inputOffset < inputLength && input[inputOffset] == c)

instPointer += sizeof(*this);

else

instPointer = matcher.LabelToInstPointer(targetLabel);

return false;

}

#if ENABLE_REGEX_CONFIG_OPTIONS

int JumpIfNotCharInst::Print(DebugWriter* w, Label label, const Char* litbuf) const

{

w->Print(_u("L%04x: JumpIfNotChar("), label);

CharMixin::Print(w, litbuf);

w->Print(_u(", "));

JumpMixin::Print(w, litbuf);

w->PrintEOL(_u(")"));

return sizeof(*this);

}

#endif

// ----------------------------------------------------------------------

// MatchCharOrJumpInst (optimized instruction)

// ----------------------------------------------------------------------

inline bool MatchCharOrJumpInst::Exec(REGEX_INST_EXEC_PARAMETERS) const

{

#if ENABLE_REGEX_CONFIG_OPTIONS

matcher.CompStats();

#endif

if (inputOffset < inputLength && input[inputOffset] == c)

{

inputOffset++;

instPointer += sizeof(*this);

}

else

instPointer = matcher.LabelToInstPointer(targetLabel);

return false;

}

#if ENABLE_REGEX_CONFIG_OPTIONS

int MatchCharOrJumpInst::Print(DebugWriter* w, Label label, const Char* litbuf) const

{

w->Print(_u("L%04x: MatchCharOrJump("), label);

CharMixin::Print(w, litbuf);

w->Print(_u(", "));

JumpMixin::Print(w, litbuf);

w->PrintEOL(_u(")"));

return sizeof(*this);

}

#endif

// ----------------------------------------------------------------------

// JumpIfNotSetInst (optimized instruction)

// ----------------------------------------------------------------------

inline bool JumpIfNotSetInst::Exec(REGEX_INST_EXEC_PARAMETERS) const

{

#if ENABLE_REGEX_CONFIG_OPTIONS

matcher.CompStats();

#endif

if (inputOffset < inputLength && set.Get(input[inputOffset]))

instPointer += sizeof(*this);

else

instPointer = matcher.LabelToInstPointer(targetLabel);

return false;

}

#if ENABLE_REGEX_CONFIG_OPTIONS

int JumpIfNotSetInst::Print(DebugWriter* w, Label label, const Char* litbuf) const

{

w->Print(_u("L%04x: JumpIfNotSet("), label);

SetMixin::Print(w, litbuf);

w->Print(_u(", "));

JumpMixin::Print(w, litbuf);

w->PrintEOL(_u(")"));

return sizeof(*this);

}

#endif

// ----------------------------------------------------------------------

// MatchSetOrJumpInst (optimized instruction)

// ----------------------------------------------------------------------

inline bool MatchSetOrJumpInst::Exec(REGEX_INST_EXEC_PARAMETERS) const

{

#if ENABLE_REGEX_CONFIG_OPTIONS

matcher.CompStats();

#endif

if (inputOffset < inputLength && set.Get(input[inputOffset]))

{

inputOffset++;

instPointer += sizeof(*this);

}

else

instPointer = matcher.LabelToInstPointer(targetLabel);

return false;

}

#if ENABLE_REGEX_CONFIG_OPTIONS

int MatchSetOrJumpInst::Print(DebugWriter* w, Label label, const Char* litbuf) const

{

w->Print(_u("L%04x: MatchSetOrJump("), label);

SetMixin::Print(w, litbuf);

w->Print(_u(", "));

JumpMixin::Print(w, litbuf);

w->PrintEOL(_u(")"));

return sizeof(*this);

}

#endif

// ----------------------------------------------------------------------

// Switch10Inst (optimized instruction)

// ----------------------------------------------------------------------

inline bool Switch10Inst::Exec(REGEX_INST_EXEC_PARAMETERS) const

{

if (inputOffset >= inputLength)

return matcher.Fail(FAIL_PARAMETERS);

#if 0

int l = 0;

int h = numCases - 1;

while (l <= h)

{

int m = (l + h) / 2;

#if ENABLE_REGEX_CONFIG_OPTIONS

matcher.CompStats();

#endif

if (cases[m].c == input[inputOffset])

{

instPointer = matcher.LabelToInstPointer(cases[m].targetLabel);

return false;

}

else if (cases[m].c < input[inputOffset])

l = m + 1;

else

h = m - 1;

}

#else

const int localNumCases = numCases;

for (int i = 0; i < localNumCases; i++)

{

#if ENABLE_REGEX_CONFIG_OPTIONS

matcher.CompStats();

#endif

if (cases[i].c == input[inputOffset])

{

instPointer = matcher.LabelToInstPointer(cases[i].targetLabel);

return false;

}

else if (cases[i].c > input[inputOffset])

break;

}

#endif

instPointer += sizeof(*this);