[apple/icu.git] / icuSources / i18n / regeximp.h

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
//
//   Copyright (C) 2002-2015 International Business Machines Corporation
//   and others. All rights reserved.
//
//   file:  regeximp.h
//
//           ICU Regular Expressions,
//               Definitions of constant values used in the compiled form of
//               a regular expression pattern.
//

#ifndef _REGEXIMP_H
#define _REGEXIMP_H

#include "unicode/utypes.h"
#include "unicode/uobject.h"
#include "unicode/uniset.h"
#include "unicode/utext.h"

#include "cmemory.h"
#include "ucase.h"

U_NAMESPACE_BEGIN

// For debugging, define REGEX_DEBUG
// To define with configure,
//   CPPFLAGS="-DREGEX_DEBUG" ./runConfigureICU --enable-debug --disable-release Linux 

#ifdef REGEX_DEBUG
//
//  debugging options.  Enable one or more of the three #defines immediately following
//

//#define REGEX_SCAN_DEBUG
#define REGEX_DUMP_DEBUG
#define REGEX_RUN_DEBUG

//  End of #defines inteded to be directly set.

#include <stdio.h>
#endif

#ifdef REGEX_SCAN_DEBUG
#define REGEX_SCAN_DEBUG_PRINTF(a) printf a
#else
#define REGEX_SCAN_DEBUG_PRINTF(a)
#endif


//
//  Opcode types     In the compiled form of the regexp, these are the type, or opcodes,
//                   of the entries.
//
enum {
     URX_RESERVED_OP   = 0,    // For multi-operand ops, most non-first words.
     URX_RESERVED_OP_N = 255,  // For multi-operand ops, negative operand values.
     URX_BACKTRACK     = 1,    // Force a backtrack, as if a match test had failed.
     URX_END           = 2,
     URX_ONECHAR       = 3,    // Value field is the 21 bit unicode char to match
     URX_STRING        = 4,    // Value field is index of string start
     URX_STRING_LEN    = 5,    // Value field is string length (code units)
     URX_STATE_SAVE    = 6,    // Value field is pattern position to push
     URX_NOP           = 7,
     URX_START_CAPTURE = 8,    // Value field is capture group number.
     URX_END_CAPTURE   = 9,    // Value field is capture group number
     URX_STATIC_SETREF = 10,   // Value field is index of set in array of sets.
     URX_SETREF        = 11,   // Value field is index of set in array of sets.
     URX_DOTANY        = 12,
     URX_JMP           = 13,   // Value field is destination position in
                                                    //   the pattern.
     URX_FAIL          = 14,   // Stop match operation,  No match.

     URX_JMP_SAV       = 15,   // Operand:  JMP destination location
     URX_BACKSLASH_B   = 16,   // Value field:  0:  \b    1:  \B
     URX_BACKSLASH_G   = 17,
     URX_JMP_SAV_X     = 18,   // Conditional JMP_SAV,
                               //    Used in (x)+, breaks loop on zero length match.
                               //    Operand:  Jmp destination.
     URX_BACKSLASH_X   = 19,
     URX_BACKSLASH_Z   = 20,   // \z   Unconditional end of line.

     URX_DOTANY_ALL    = 21,   // ., in the . matches any mode.
     URX_BACKSLASH_D   = 22,   // Value field:  0:  \d    1:  \D
     URX_CARET         = 23,   // Value field:  1:  multi-line mode.
     URX_DOLLAR        = 24,  // Also for \Z

     URX_CTR_INIT      = 25,   // Counter Inits for {Interval} loops.
     URX_CTR_INIT_NG   = 26,   //   2 kinds, normal and non-greedy.
                               //   These are 4 word opcodes.  See description.
                               //    First Operand:  Data loc of counter variable
                               //    2nd   Operand:  Pat loc of the URX_CTR_LOOPx
                               //                    at the end of the loop.
                               //    3rd   Operand:  Minimum count.
                               //    4th   Operand:  Max count, -1 for unbounded.

     URX_DOTANY_UNIX   = 27,   // '.' operator in UNIX_LINES mode, only \n marks end of line.

     URX_CTR_LOOP      = 28,   // Loop Ops for {interval} loops.
     URX_CTR_LOOP_NG   = 29,   //   Also in three flavors.
                               //   Operand is loc of corresponding CTR_INIT.

     URX_CARET_M_UNIX  = 30,   // '^' operator, test for start of line in multi-line
                               //      plus UNIX_LINES mode.

     URX_RELOC_OPRND   = 31,   // Operand value in multi-operand ops that refers
                               //   back into compiled pattern code, and thus must
                               //   be relocated when inserting/deleting ops in code.

     URX_STO_SP        = 32,   // Store the stack ptr.  Operand is location within
                               //   matcher data (not stack data) to store it.
     URX_LD_SP         = 33,   // Load the stack pointer.  Operand is location
                               //   to load from.
     URX_BACKREF       = 34,   // Back Reference.  Parameter is the index of the
                               //   capture group variables in the state stack frame.
     URX_STO_INP_LOC   = 35,   // Store the input location.  Operand is location
                               //   within the matcher stack frame.
     URX_JMPX          = 36,  // Conditional JMP.
                               //   First Operand:  JMP target location.
                               //   Second Operand:  Data location containing an
                               //     input position.  If current input position ==
                               //     saved input position, FAIL rather than taking
                               //     the JMP
     URX_LA_START      = 37,   // Starting a LookAround expression.
                               //   Save InputPos and SP in static data.
                               //   Operand:  Static data offset for the save
     URX_LA_END        = 38,   // Ending a Lookaround expression.
                               //   Restore InputPos and Stack to saved values.
                               //   Operand:  Static data offset for saved data.
     URX_ONECHAR_I     = 39,   // Test for case-insensitive match of a literal character.
                               //   Operand:  the literal char.
     URX_STRING_I      = 40,   // Case insensitive string compare.
                               //   First Operand:  Index of start of string in string literals
                               //   Second Operand (next word in compiled code):
                               //     the length of the string.
     URX_BACKREF_I     = 41,   // Case insensitive back reference.
                               //   Parameter is the index of the
                               //   capture group variables in the state stack frame.
     URX_DOLLAR_M      = 42,   // $ in multi-line mode.
     URX_CARET_M       = 43,   // ^ in multi-line mode.
     URX_LB_START      = 44,   // LookBehind Start.
                               //   Paramater is data location
     URX_LB_CONT       = 45,   // LookBehind Continue.
                               //   Param 0:  the data location
                               //   Param 1:  The minimum length of the look-behind match
                               //   Param 2:  The max length of the look-behind match
     URX_LB_END        = 46,   // LookBehind End.
                               //   Parameter is the data location.
                               //     Check that match ended at the right spot,
                               //     Restore original input string len.
     URX_LBN_CONT      = 47,   // Negative LookBehind Continue
                               //   Param 0:  the data location
                               //   Param 1:  The minimum length of the look-behind match
                               //   Param 2:  The max     length of the look-behind match
                               //   Param 3:  The pattern loc following the look-behind block.
     URX_LBN_END       = 48,   // Negative LookBehind end
                               //   Parameter is the data location.
                               //   Check that the match ended at the right spot.
     URX_STAT_SETREF_N = 49,   // Reference to a prebuilt set (e.g. \w), negated
                               //   Operand is index of set in array of sets.
     URX_LOOP_SR_I     = 50,   // Init a [set]* loop.
                               //   Operand is the sets index in array of user sets.
     URX_LOOP_C        = 51,   // Continue a [set]* or OneChar* loop.
                               //   Operand is a matcher static data location.
                               //   Must always immediately follow  LOOP_x_I instruction.
     URX_LOOP_DOT_I    = 52,   // .*, initialization of the optimized loop.
                               //   Operand value:
                               //      bit 0:
                               //         0:  Normal (. doesn't match new-line) mode.
                               //         1:  . matches new-line mode.
                               //      bit 1:  controls what new-lines are recognized by this operation.
                               //         0:  All Unicode New-lines
                               //         1:  UNIX_LINES, \u000a only.
     URX_BACKSLASH_BU  = 53,   // \b or \B in UREGEX_UWORD mode, using Unicode style
                               //   word boundaries.
     URX_DOLLAR_D      = 54,   // $ end of input test, in UNIX_LINES mode.
     URX_DOLLAR_MD     = 55,   // $ end of input test, in MULTI_LINE and UNIX_LINES mode.
     URX_BACKSLASH_H   = 56,   // Value field:  0:  \h    1:  \H
     URX_BACKSLASH_R   = 57,   // Any line break sequence.
     URX_BACKSLASH_V   = 58    // Value field:  0:  \v    1:  \V

};

// Keep this list of opcode names in sync with the above enum
//   Used for debug printing only.
#define URX_OPCODE_NAMES       \
        "               ",     \
        "BACKTRACK",           \
        "END",                 \
        "ONECHAR",             \
        "STRING",              \
        "STRING_LEN",          \
        "STATE_SAVE",          \
        "NOP",                 \
        "START_CAPTURE",       \
        "END_CAPTURE",         \
        "URX_STATIC_SETREF",   \
        "SETREF",              \
        "DOTANY",              \
        "JMP",                 \
        "FAIL",                \
        "JMP_SAV",             \
        "BACKSLASH_B",         \
        "BACKSLASH_G",         \
        "JMP_SAV_X",           \
        "BACKSLASH_X",         \
        "BACKSLASH_Z",         \
        "DOTANY_ALL",          \
        "BACKSLASH_D",         \
        "CARET",               \
        "DOLLAR",              \
        "CTR_INIT",            \
        "CTR_INIT_NG",         \
        "DOTANY_UNIX",         \
        "CTR_LOOP",            \
        "CTR_LOOP_NG",         \
        "URX_CARET_M_UNIX",    \
        "RELOC_OPRND",         \
        "STO_SP",              \
        "LD_SP",               \
        "BACKREF",             \
        "STO_INP_LOC",         \
        "JMPX",                \
        "LA_START",            \
        "LA_END",              \
        "ONECHAR_I",           \
        "STRING_I",            \
        "BACKREF_I",           \
        "DOLLAR_M",            \
        "CARET_M",             \
        "LB_START",            \
        "LB_CONT",             \
        "LB_END",              \
        "LBN_CONT",            \
        "LBN_END",             \
        "STAT_SETREF_N",       \
        "LOOP_SR_I",           \
        "LOOP_C",              \
        "LOOP_DOT_I",          \
        "BACKSLASH_BU",        \
        "DOLLAR_D",            \
        "DOLLAR_MD",           \
        "URX_BACKSLASH_H",     \
        "URX_BACKSLASH_R",     \
        "URX_BACKSLASH_V" 


//
//  Convenience macros for assembling and disassembling a compiled operation.
//
#define URX_TYPE(x)          ((uint32_t)(x) >> 24)
#define URX_VAL(x)           ((x) & 0xffffff)


//
//  Access to Unicode Sets composite character properties
//     The sets are accessed by the match engine for things like \w (word boundary)
//
enum {
     URX_ISWORD_SET  = 1,
     URX_ISALNUM_SET = 2,
     URX_ISALPHA_SET = 3,
     URX_ISSPACE_SET = 4,

     URX_GC_NORMAL,          // Sets for finding grapheme cluster boundaries.
     URX_GC_EXTEND,
     URX_GC_CONTROL,
     URX_GC_L,
     URX_GC_LV,
     URX_GC_LVT,
     URX_GC_V,
     URX_GC_T,

     URX_LAST_SET,

     URX_NEG_SET     = 0x800000          // Flag bit to reverse sense of set
                                         //   membership test.
};


//
//  Match Engine State Stack Frame Layout.
//
struct REStackFrame {
    // Header
    int64_t            fInputIdx;        // Position of next character in the input string
    int64_t            fPatIdx;          // Position of next Op in the compiled pattern
                                         // (int64_t for UVector64, values fit in an int32_t)
    // Remainder
    int64_t            fExtra[1];        // Extra state, for capture group start/ends
                                         //   atomic parentheses, repeat counts, etc.
                                         //   Locations assigned at pattern compile time.
                                         //   Variable-length array.
};
// number of UVector elements in the header
#define RESTACKFRAME_HDRCOUNT 2

//
//  Start-Of-Match type.  Used by find() to quickly scan to positions where a
//                        match might start before firing up the full match engine.
//
enum StartOfMatch {
    START_NO_INFO,             // No hint available.
    START_CHAR,                // Match starts with a literal code point.
    START_SET,                 // Match starts with something matching a set.
    START_START,               // Match starts at start of buffer only (^ or \A)
    START_LINE,                // Match starts with ^ in multi-line mode.
    START_STRING               // Match starts with a literal string.
};

#define START_OF_MATCH_STR(v) ((v)==START_NO_INFO? "START_NO_INFO" : \
                               (v)==START_CHAR?    "START_CHAR"    : \
                               (v)==START_SET?     "START_SET"     : \
                               (v)==START_START?   "START_START"   : \
                               (v)==START_LINE?    "START_LINE"    : \
                               (v)==START_STRING?  "START_STRING"  : \
                                                   "ILLEGAL")

//
//  8 bit set, to fast-path latin-1 set membership tests.
//
struct Regex8BitSet : public UMemory {
    inline Regex8BitSet();
    inline void operator = (const Regex8BitSet &s);
    inline void init(const UnicodeSet *src);
    inline UBool contains(UChar32 c);
    inline void  add(UChar32 c);
    int8_t d[32];
};

inline Regex8BitSet::Regex8BitSet() {
    uprv_memset(d, 0, sizeof(d));
}

inline UBool Regex8BitSet::contains(UChar32 c) {
    // No bounds checking!  This is deliberate.
    return ((d[c>>3] & 1 <<(c&7)) != 0);
}

inline void  Regex8BitSet::add(UChar32 c) {
    d[c>>3] |= 1 << (c&7);
}

inline void Regex8BitSet::init(const UnicodeSet *s) {
    if (s != NULL) {
        for (int32_t i=0; i<=255; i++) {
            if (s->contains(i)) {
                this->add(i);
            }
        }
    }
}

inline void Regex8BitSet::operator = (const Regex8BitSet &s) {
   uprv_memcpy(d, s.d, sizeof(d));
}


//  Case folded UText Iterator helper class.
//  Wraps a UText, provides a case-folded enumeration over its contents.
//  Used in implementing case insensitive matching constructs.
//  Implementation in rematch.cpp

class CaseFoldingUTextIterator: public UMemory {
      public:
        CaseFoldingUTextIterator(UText &text);
        ~CaseFoldingUTextIterator();

        UChar32 next();           // Next case folded character

        UBool   inExpansion();    // True if last char returned from next() and the
                                  //  next to be returned both originated from a string
                                  //  folding of the same code point from the orignal UText.
      private:
        UText             &fUText;
        const  UChar      *fFoldChars;
        int32_t            fFoldLength;
        int32_t            fFoldIndex;

};


// Case folded UChar * string iterator.
//  Wraps a UChar  *, provides a case-folded enumeration over its contents.
//  Used in implementing case insensitive matching constructs.
//  Implementation in rematch.cpp

class CaseFoldingUCharIterator: public UMemory {
      public:
        CaseFoldingUCharIterator(const UChar *chars, int64_t start, int64_t limit);
        ~CaseFoldingUCharIterator();

        UChar32 next();           // Next case folded character

        UBool   inExpansion();    // True if last char returned from next() and the
                                  //  next to be returned both originated from a string
                                  //  folding of the same code point from the orignal UText.

        int64_t  getIndex();      // Return the current input buffer index.

      private:
        const  UChar      *fChars;
        int64_t            fIndex;
        int64_t            fLimit;
        const  UChar      *fFoldChars;
        int32_t            fFoldLength;
        int32_t            fFoldIndex;

};

U_NAMESPACE_END
#endif
Commit	Line	Data
f3c0d7a5 A	1	// © 2016 and later: Unicode, Inc. and others.
f3c0d7a5 A	2	// License & terms of use: http://www.unicode.org/copyright.html
46f4442e	3	//
b331163b	4	// Copyright (C) 2002-2015 International Business Machines Corporation
46f4442e	5	// and others. All rights reserved.
b75a7d8f A	6	//
	7	// file: regeximp.h
	8	//
	9	// ICU Regular Expressions,
	10	// Definitions of constant values used in the compiled form of
	11	// a regular expression pattern.
	12	//
	13
	14	#ifndef _REGEXIMP_H
	15	#define _REGEXIMP_H
	16
4388f060 A	17	#include "unicode/utypes.h"
	18	#include "unicode/uobject.h"
	19	#include "unicode/uniset.h"
	20	#include "unicode/utext.h"
	21
b75a7d8f	22	#include "cmemory.h"
4388f060	23	#include "ucase.h"
b75a7d8f A	24
	25	U_NAMESPACE_BEGIN
	26
57a6839d	27	// For debugging, define REGEX_DEBUG
4388f060	28	// To define with configure,
57a6839d	29	// CPPFLAGS="-DREGEX_DEBUG" ./runConfigureICU --enable-debug --disable-release Linux
4388f060	30
57a6839d	31	#ifdef REGEX_DEBUG
b75a7d8f	32	//
374ca955	33	// debugging options. Enable one or more of the three #defines immediately following
b75a7d8f	34	//
374ca955	35
b75a7d8f	36	//#define REGEX_SCAN_DEBUG
374ca955 A	37	#define REGEX_DUMP_DEBUG
	38	#define REGEX_RUN_DEBUG
	39
b75a7d8f A	40	// End of #defines inteded to be directly set.
b75a7d8f A	41
b75a7d8f A	42	#include <stdio.h>
	43	#endif
	44
	45	#ifdef REGEX_SCAN_DEBUG
374ca955	46	#define REGEX_SCAN_DEBUG_PRINTF(a) printf a
b75a7d8f	47	#else
374ca955	48	#define REGEX_SCAN_DEBUG_PRINTF(a)
b75a7d8f A	49	#endif
b75a7d8f A	50
b75a7d8f A	51
	52	//
	53	// Opcode types In the compiled form of the regexp, these are the type, or opcodes,
	54	// of the entries.
	55	//
	56	enum {
	57	URX_RESERVED_OP = 0, // For multi-operand ops, most non-first words.
	58	URX_RESERVED_OP_N = 255, // For multi-operand ops, negative operand values.
46f4442e	59	URX_BACKTRACK = 1, // Force a backtrack, as if a match test had failed.
b75a7d8f A	60	URX_END = 2,
	61	URX_ONECHAR = 3, // Value field is the 21 bit unicode char to match
	62	URX_STRING = 4, // Value field is index of string start
	63	URX_STRING_LEN = 5, // Value field is string length (code units)
	64	URX_STATE_SAVE = 6, // Value field is pattern position to push
	65	URX_NOP = 7,
	66	URX_START_CAPTURE = 8, // Value field is capture group number.
	67	URX_END_CAPTURE = 9, // Value field is capture group number
46f4442e	68	URX_STATIC_SETREF = 10, // Value field is index of set in array of sets.
b75a7d8f	69	URX_SETREF = 11, // Value field is index of set in array of sets.
46f4442e	70	URX_DOTANY = 12,
b75a7d8f A	71	URX_JMP = 13, // Value field is destination position in
	72	// the pattern.
	73	URX_FAIL = 14, // Stop match operation, No match.
	74
	75	URX_JMP_SAV = 15, // Operand: JMP destination location
	76	URX_BACKSLASH_B = 16, // Value field: 0: \b 1: \B
46f4442e	77	URX_BACKSLASH_G = 17,
b75a7d8f A	78	URX_JMP_SAV_X = 18, // Conditional JMP_SAV,
	79	// Used in (x)+, breaks loop on zero length match.
	80	// Operand: Jmp destination.
	81	URX_BACKSLASH_X = 19,
	82	URX_BACKSLASH_Z = 20, // \z Unconditional end of line.
	83
	84	URX_DOTANY_ALL = 21, // ., in the . matches any mode.
	85	URX_BACKSLASH_D = 22, // Value field: 0: \d 1: \D
	86	URX_CARET = 23, // Value field: 1: multi-line mode.
	87	URX_DOLLAR = 24, // Also for \Z
	88
	89	URX_CTR_INIT = 25, // Counter Inits for {Interval} loops.
46f4442e	90	URX_CTR_INIT_NG = 26, // 2 kinds, normal and non-greedy.
b75a7d8f A	91	// These are 4 word opcodes. See description.
b75a7d8f A	92	// First Operand: Data loc of counter variable
46f4442e	93	// 2nd Operand: Pat loc of the URX_CTR_LOOPx
b75a7d8f A	94	// at the end of the loop.
	95	// 3rd Operand: Minimum count.
	96	// 4th Operand: Max count, -1 for unbounded.
	97
46f4442e	98	URX_DOTANY_UNIX = 27, // '.' operator in UNIX_LINES mode, only \n marks end of line.
b75a7d8f A	99
	100	URX_CTR_LOOP = 28, // Loop Ops for {interval} loops.
	101	URX_CTR_LOOP_NG = 29, // Also in three flavors.
	102	// Operand is loc of corresponding CTR_INIT.
	103
46f4442e A	104	URX_CARET_M_UNIX = 30, // '^' operator, test for start of line in multi-line
46f4442e A	105	// plus UNIX_LINES mode.
b75a7d8f A	106
	107	URX_RELOC_OPRND = 31, // Operand value in multi-operand ops that refers
	108	// back into compiled pattern code, and thus must
	109	// be relocated when inserting/deleting ops in code.
	110
	111	URX_STO_SP = 32, // Store the stack ptr. Operand is location within
	112	// matcher data (not stack data) to store it.
	113	URX_LD_SP = 33, // Load the stack pointer. Operand is location
	114	// to load from.
	115	URX_BACKREF = 34, // Back Reference. Parameter is the index of the
	116	// capture group variables in the state stack frame.
	117	URX_STO_INP_LOC = 35, // Store the input location. Operand is location
	118	// within the matcher stack frame.
	119	URX_JMPX = 36, // Conditional JMP.
	120	// First Operand: JMP target location.
46f4442e	121	// Second Operand: Data location containing an
b75a7d8f A	122	// input position. If current input position ==
	123	// saved input position, FAIL rather than taking
	124	// the JMP
	125	URX_LA_START = 37, // Starting a LookAround expression.
	126	// Save InputPos and SP in static data.
	127	// Operand: Static data offset for the save
	128	URX_LA_END = 38, // Ending a Lookaround expression.
	129	// Restore InputPos and Stack to saved values.
	130	// Operand: Static data offset for saved data.
	131	URX_ONECHAR_I = 39, // Test for case-insensitive match of a literal character.
	132	// Operand: the literal char.
	133	URX_STRING_I = 40, // Case insensitive string compare.
	134	// First Operand: Index of start of string in string literals
	135	// Second Operand (next word in compiled code):
	136	// the length of the string.
	137	URX_BACKREF_I = 41, // Case insensitive back reference.
	138	// Parameter is the index of the
	139	// capture group variables in the state stack frame.
	140	URX_DOLLAR_M = 42, // $ in multi-line mode.
	141	URX_CARET_M = 43, // ^ in multi-line mode.
	142	URX_LB_START = 44, // LookBehind Start.
	143	// Paramater is data location
	144	URX_LB_CONT = 45, // LookBehind Continue.
	145	// Param 0: the data location
	146	// Param 1: The minimum length of the look-behind match
	147	// Param 2: The max length of the look-behind match
	148	URX_LB_END = 46, // LookBehind End.
	149	// Parameter is the data location.
	150	// Check that match ended at the right spot,
	151	// Restore original input string len.
	152	URX_LBN_CONT = 47, // Negative LookBehind Continue
	153	// Param 0: the data location
	154	// Param 1: The minimum length of the look-behind match
	155	// Param 2: The max length of the look-behind match
	156	// Param 3: The pattern loc following the look-behind block.
	157	URX_LBN_END = 48, // Negative LookBehind end
	158	// Parameter is the data location.
	159	// Check that the match ended at the right spot.
46f4442e	160	URX_STAT_SETREF_N = 49, // Reference to a prebuilt set (e.g. \w), negated
b75a7d8f A	161	// Operand is index of set in array of sets.
	162	URX_LOOP_SR_I = 50, // Init a [set]* loop.
	163	// Operand is the sets index in array of user sets.
	164	URX_LOOP_C = 51, // Continue a [set]* or OneChar* loop.
	165	// Operand is a matcher static data location.
	166	// Must always immediately follow LOOP_x_I instruction.
374ca955	167	URX_LOOP_DOT_I = 52, // .*, initialization of the optimized loop.
b75a7d8f	168	// Operand value:
46f4442e A	169	// bit 0:
	170	// 0: Normal (. doesn't match new-line) mode.
	171	// 1: . matches new-line mode.
	172	// bit 1: controls what new-lines are recognized by this operation.
	173	// 0: All Unicode New-lines
	174	// 1: UNIX_LINES, \u000a only.
	175	URX_BACKSLASH_BU = 53, // \b or \B in UREGEX_UWORD mode, using Unicode style
374ca955	176	// word boundaries.
46f4442e	177	URX_DOLLAR_D = 54, // $ end of input test, in UNIX_LINES mode.
b331163b A	178	URX_DOLLAR_MD = 55, // $ end of input test, in MULTI_LINE and UNIX_LINES mode.
	179	URX_BACKSLASH_H = 56, // Value field: 0: \h 1: \H
	180	URX_BACKSLASH_R = 57, // Any line break sequence.
	181	URX_BACKSLASH_V = 58 // Value field: 0: \v 1: \V
b75a7d8f	182
46f4442e	183	};
b75a7d8f A	184
	185	// Keep this list of opcode names in sync with the above enum
	186	// Used for debug printing only.
	187	#define URX_OPCODE_NAMES \
	188	" ", \
	189	"BACKTRACK", \
	190	"END", \
	191	"ONECHAR", \
	192	"STRING", \
	193	"STRING_LEN", \
	194	"STATE_SAVE", \
	195	"NOP", \
	196	"START_CAPTURE", \
	197	"END_CAPTURE", \
	198	"URX_STATIC_SETREF", \
	199	"SETREF", \
	200	"DOTANY", \
	201	"JMP", \
	202	"FAIL", \
	203	"JMP_SAV", \
	204	"BACKSLASH_B", \
	205	"BACKSLASH_G", \
	206	"JMP_SAV_X", \
	207	"BACKSLASH_X", \
	208	"BACKSLASH_Z", \
	209	"DOTANY_ALL", \
	210	"BACKSLASH_D", \
	211	"CARET", \
	212	"DOLLAR", \
	213	"CTR_INIT", \
	214	"CTR_INIT_NG", \
46f4442e	215	"DOTANY_UNIX", \
b75a7d8f A	216	"CTR_LOOP", \
b75a7d8f A	217	"CTR_LOOP_NG", \
46f4442e	218	"URX_CARET_M_UNIX", \
b75a7d8f A	219	"RELOC_OPRND", \
	220	"STO_SP", \
	221	"LD_SP", \
	222	"BACKREF", \
	223	"STO_INP_LOC", \
	224	"JMPX", \
	225	"LA_START", \
	226	"LA_END", \
	227	"ONECHAR_I", \
	228	"STRING_I", \
	229	"BACKREF_I", \
	230	"DOLLAR_M", \
	231	"CARET_M", \
	232	"LB_START", \
	233	"LB_CONT", \
	234	"LB_END", \
	235	"LBN_CONT", \
	236	"LBN_END", \
	237	"STAT_SETREF_N", \
	238	"LOOP_SR_I", \
	239	"LOOP_C", \
374ca955	240	"LOOP_DOT_I", \
46f4442e A	241	"BACKSLASH_BU", \
46f4442e A	242	"DOLLAR_D", \
b331163b A	243	"DOLLAR_MD", \
	244	"URX_BACKSLASH_H", \
	245	"URX_BACKSLASH_R", \
	246	"URX_BACKSLASH_V"
b75a7d8f A	247
	248
	249	//
	250	// Convenience macros for assembling and disassembling a compiled operation.
	251	//
46f4442e	252	#define URX_TYPE(x) ((uint32_t)(x) >> 24)
b75a7d8f A	253	#define URX_VAL(x) ((x) & 0xffffff)
b75a7d8f A	254
46f4442e	255
b75a7d8f A	256	//
	257	// Access to Unicode Sets composite character properties
	258	// The sets are accessed by the match engine for things like \w (word boundary)
46f4442e	259	//
b75a7d8f A	260	enum {
	261	URX_ISWORD_SET = 1,
	262	URX_ISALNUM_SET = 2,
	263	URX_ISALPHA_SET = 3,
	264	URX_ISSPACE_SET = 4,
	265
	266	URX_GC_NORMAL, // Sets for finding grapheme cluster boundaries.
	267	URX_GC_EXTEND,
	268	URX_GC_CONTROL,
	269	URX_GC_L,
	270	URX_GC_LV,
	271	URX_GC_LVT,
	272	URX_GC_V,
	273	URX_GC_T,
	274
	275	URX_LAST_SET,
	276
	277	URX_NEG_SET = 0x800000 // Flag bit to reverse sense of set
	278	// membership test.
	279	};
	280
	281
	282	//
	283	// Match Engine State Stack Frame Layout.
	284	//
	285	struct REStackFrame {
729e4ab9 A	286	// Header
	287	int64_t fInputIdx; // Position of next character in the input string
	288	int64_t fPatIdx; // Position of next Op in the compiled pattern
	289	// (int64_t for UVector64, values fit in an int32_t)
	290	// Remainder
	291	int64_t fExtra[1]; // Extra state, for capture group start/ends
b75a7d8f A	292	// atomic parentheses, repeat counts, etc.
b75a7d8f A	293	// Locations assigned at pattern compile time.
729e4ab9	294	// Variable-length array.
b75a7d8f	295	};
729e4ab9 A	296	// number of UVector elements in the header
729e4ab9 A	297	#define RESTACKFRAME_HDRCOUNT 2
b75a7d8f A	298
	299	//
	300	// Start-Of-Match type. Used by find() to quickly scan to positions where a
	301	// match might start before firing up the full match engine.
	302	//
	303	enum StartOfMatch {
	304	START_NO_INFO, // No hint available.
	305	START_CHAR, // Match starts with a literal code point.
	306	START_SET, // Match starts with something matching a set.
	307	START_START, // Match starts at start of buffer only (^ or \A)
	308	START_LINE, // Match starts with ^ in multi-line mode.
	309	START_STRING // Match starts with a literal string.
	310	};
	311
	312	#define START_OF_MATCH_STR(v) ((v)==START_NO_INFO? "START_NO_INFO" : \
	313	(v)==START_CHAR? "START_CHAR" : \
	314	(v)==START_SET? "START_SET" : \
	315	(v)==START_START? "START_START" : \
	316	(v)==START_LINE? "START_LINE" : \
	317	(v)==START_STRING? "START_STRING" : \
	318	"ILLEGAL")
46f4442e	319
b75a7d8f A	320	//
	321	// 8 bit set, to fast-path latin-1 set membership tests.
	322	//
	323	struct Regex8BitSet : public UMemory {
	324	inline Regex8BitSet();
	325	inline void operator = (const Regex8BitSet &s);
	326	inline void init(const UnicodeSet *src);
	327	inline UBool contains(UChar32 c);
	328	inline void add(UChar32 c);
	329	int8_t d[32];
	330	};
	331
	332	inline Regex8BitSet::Regex8BitSet() {
	333	uprv_memset(d, 0, sizeof(d));
	334	}
	335
	336	inline UBool Regex8BitSet::contains(UChar32 c) {
	337	// No bounds checking! This is deliberate.
	338	return ((d[c>>3] & 1 <<(c&7)) != 0);
73c04bcf	339	}
b75a7d8f A	340
	341	inline void Regex8BitSet::add(UChar32 c) {
	342	d[c>>3] \|= 1 << (c&7);
73c04bcf	343	}
b75a7d8f A	344
	345	inline void Regex8BitSet::init(const UnicodeSet *s) {
	346	if (s != NULL) {
73c04bcf	347	for (int32_t i=0; i<=255; i++) {
b75a7d8f A	348	if (s->contains(i)) {
	349	this->add(i);
	350	}
	351	}
	352	}
	353	}
	354
	355	inline void Regex8BitSet::operator = (const Regex8BitSet &s) {
	356	uprv_memcpy(d, s.d, sizeof(d));
	357	}
	358
4388f060 A	359
	360	// Case folded UText Iterator helper class.
	361	// Wraps a UText, provides a case-folded enumeration over its contents.
	362	// Used in implementing case insensitive matching constructs.
	363	// Implementation in rematch.cpp
	364
	365	class CaseFoldingUTextIterator: public UMemory {
	366	public:
	367	CaseFoldingUTextIterator(UText &text);
	368	~CaseFoldingUTextIterator();
	369
57a6839d	370	UChar32 next(); // Next case folded character
4388f060	371
57a6839d	372	UBool inExpansion(); // True if last char returned from next() and the
4388f060 A	373	// next to be returned both originated from a string
	374	// folding of the same code point from the orignal UText.
	375	private:
	376	UText &fUText;
4388f060 A	377	const UChar *fFoldChars;
	378	int32_t fFoldLength;
	379	int32_t fFoldIndex;
	380
	381	};
	382
	383
	384	// Case folded UChar * string iterator.
	385	// Wraps a UChar *, provides a case-folded enumeration over its contents.
	386	// Used in implementing case insensitive matching constructs.
	387	// Implementation in rematch.cpp
	388
	389	class CaseFoldingUCharIterator: public UMemory {
	390	public:
	391	CaseFoldingUCharIterator(const UChar *chars, int64_t start, int64_t limit);
	392	~CaseFoldingUCharIterator();
	393
57a6839d	394	UChar32 next(); // Next case folded character
4388f060	395
57a6839d	396	UBool inExpansion(); // True if last char returned from next() and the
4388f060 A	397	// next to be returned both originated from a string
	398	// folding of the same code point from the orignal UText.
	399
	400	int64_t getIndex(); // Return the current input buffer index.
	401
	402	private:
	403	const UChar *fChars;
	404	int64_t fIndex;
	405	int64_t fLimit;
4388f060 A	406	const UChar *fFoldChars;
	407	int32_t fFoldLength;
	408	int32_t fFoldIndex;
	409
	410	};
	411
b75a7d8f A	412	U_NAMESPACE_END
	413	#endif
	414