/* GRegex -- regular expression API wrapper around PCRE.

 *

 * Copyright (C) 1999, 2000 Scott Wimer

 * Copyright (C) 2004, Matthias Clasen <mclasen@redhat.com>

 * Copyright (C) 2005 - 2007, Marco Barisione <marco@barisione.org>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this library; if not, see <http://www.gnu.org/licenses/>.

 */

#include "config.h"

#include <string.h>

#ifdef USE_SYSTEM_PCRE

#include <pcre.h>

#else

#include "pcre/pcre.h"

#endif

#include "gtypes.h"

#include "gregex.h"

#include "glibintl.h"

#include "glist.h"

#include "gmessages.h"

#include "gstrfuncs.h"

#include "gatomic.h"

#include "gthread.h"

/**

 * SECTION:gregex

 * @title: Perl-compatible regular expressions

 * @short_description: matches strings against regular expressions

 * @see_also: [Regular expression syntax][glib-regex-syntax]

 *

 * The g_regex_*() functions implement regular

 * expression pattern matching using syntax and semantics similar to

 * Perl regular expression.

 *

 * Some functions accept a @start_position argument, setting it differs

 * from just passing over a shortened string and setting #G_REGEX_MATCH_NOTBOL

 * in the case of a pattern that begins with any kind of lookbehind assertion.

 * For example, consider the pattern "\Biss\B" which finds occurrences of "iss"

 * in the middle of words. ("\B" matches only if the current position in the

 * subject is not a word boundary.) When applied to the string "Mississipi"

 * from the fourth byte, namely "issipi", it does not match, because "\B" is

 * always false at the start of the subject, which is deemed to be a word

 * boundary. However, if the entire string is passed , but with

 * @start_position set to 4, it finds the second occurrence of "iss" because

 * it is able to look behind the starting point to discover that it is

 * preceded by a letter.

 *

 * Note that, unless you set the #G_REGEX_RAW flag, all the strings passed

 * to these functions must be encoded in UTF-8. The lengths and the positions

 * inside the strings are in bytes and not in characters, so, for instance,

 * "\xc3\xa0" (i.e. "à") is two bytes long but it is treated as a

 * single character. If you set #G_REGEX_RAW the strings can be non-valid

 * UTF-8 strings and a byte is treated as a character, so "\xc3\xa0" is two

 * bytes and two characters long.

 *

 * When matching a pattern, "\n" matches only against a "\n" character in

 * the string, and "\r" matches only a "\r" character. To match any newline

 * sequence use "\R". This particular group matches either the two-character

 * sequence CR + LF ("\r\n"), or one of the single characters LF (linefeed,

 * U+000A, "\n"), VT vertical tab, U+000B, "\v"), FF (formfeed, U+000C, "\f"),

 * CR (carriage return, U+000D, "\r"), NEL (next line, U+0085), LS (line

 * separator, U+2028), or PS (paragraph separator, U+2029).

 *

 * The behaviour of the dot, circumflex, and dollar metacharacters are

 * affected by newline characters, the default is to recognize any newline

 * character (the same characters recognized by "\R"). This can be changed

 * with #G_REGEX_NEWLINE_CR, #G_REGEX_NEWLINE_LF and #G_REGEX_NEWLINE_CRLF

 * compile options, and with #G_REGEX_MATCH_NEWLINE_ANY,

 * #G_REGEX_MATCH_NEWLINE_CR, #G_REGEX_MATCH_NEWLINE_LF and

 * #G_REGEX_MATCH_NEWLINE_CRLF match options. These settings are also

 * relevant when compiling a pattern if #G_REGEX_EXTENDED is set, and an

 * unescaped "#" outside a character class is encountered. This indicates

 * a comment that lasts until after the next newline.

 *

 * When setting the %G_REGEX_JAVASCRIPT_COMPAT flag, pattern syntax and pattern

 * matching is changed to be compatible with the way that regular expressions

 * work in JavaScript. More precisely, a lonely ']' character in the pattern

 * is a syntax error; the '\x' escape only allows 0 to 2 hexadecimal digits, and

 * you must use the '\u' escape sequence with 4 hex digits to specify a unicode

 * codepoint instead of '\x' or 'x{....}'. If '\x' or '\u' are not followed by

 * the specified number of hex digits, they match 'x' and 'u' literally; also

 * '\U' always matches 'U' instead of being an error in the pattern. Finally,

 * pattern matching is modified so that back references to an unset subpattern

 * group produces a match with the empty string instead of an error. See

 * pcreapi(3) for more information.

 *

 * Creating and manipulating the same #GRegex structure from different

 * threads is not a problem as #GRegex does not modify its internal

 * state between creation and destruction, on the other hand #GMatchInfo

 * is not threadsafe.

 *

 * The regular expressions low-level functionalities are obtained through

 * the excellent

 * [PCRE](http://www.pcre.org/)

 * library written by Philip Hazel.

 */

/* Mask of all the possible values for GRegexCompileFlags. */

#define G_REGEX_COMPILE_MASK (G_REGEX_CASELESS          | \

                              G_REGEX_MULTILINE         | \

                              G_REGEX_DOTALL            | \

                              G_REGEX_EXTENDED          | \

                              G_REGEX_ANCHORED          | \

                              G_REGEX_DOLLAR_ENDONLY    | \

                              G_REGEX_UNGREEDY          | \

                              G_REGEX_RAW               | \

                              G_REGEX_NO_AUTO_CAPTURE   | \

                              G_REGEX_OPTIMIZE          | \

                              G_REGEX_FIRSTLINE         | \

                              G_REGEX_DUPNAMES          | \

                              G_REGEX_NEWLINE_CR        | \

                              G_REGEX_NEWLINE_LF        | \

                              G_REGEX_NEWLINE_CRLF      | \

                              G_REGEX_NEWLINE_ANYCRLF   | \

                              G_REGEX_BSR_ANYCRLF       | \

                              G_REGEX_JAVASCRIPT_COMPAT)

/* Mask of all GRegexCompileFlags values that are (not) passed trough to PCRE */

#define G_REGEX_COMPILE_PCRE_MASK (G_REGEX_COMPILE_MASK & ~G_REGEX_COMPILE_NONPCRE_MASK)

#define G_REGEX_COMPILE_NONPCRE_MASK (G_REGEX_RAW              | \

                                      G_REGEX_OPTIMIZE)

/* Mask of all the possible values for GRegexMatchFlags. */

#define G_REGEX_MATCH_MASK (G_REGEX_MATCH_ANCHORED         | \

                            G_REGEX_MATCH_NOTBOL           | \

                            G_REGEX_MATCH_NOTEOL           | \

                            G_REGEX_MATCH_NOTEMPTY         | \

                            G_REGEX_MATCH_PARTIAL          | \

                            G_REGEX_MATCH_NEWLINE_CR       | \

                            G_REGEX_MATCH_NEWLINE_LF       | \

                            G_REGEX_MATCH_NEWLINE_CRLF     | \

                            G_REGEX_MATCH_NEWLINE_ANY      | \

                            G_REGEX_MATCH_NEWLINE_ANYCRLF  | \

                            G_REGEX_MATCH_BSR_ANYCRLF      | \

                            G_REGEX_MATCH_BSR_ANY          | \

                            G_REGEX_MATCH_PARTIAL_SOFT     | \

                            G_REGEX_MATCH_PARTIAL_HARD     | \

                            G_REGEX_MATCH_NOTEMPTY_ATSTART)

/* we rely on these flags having the same values */

G_STATIC_ASSERT (G_REGEX_CASELESS          == PCRE_CASELESS);

G_STATIC_ASSERT (G_REGEX_MULTILINE         == PCRE_MULTILINE);

G_STATIC_ASSERT (G_REGEX_DOTALL            == PCRE_DOTALL);

G_STATIC_ASSERT (G_REGEX_EXTENDED          == PCRE_EXTENDED);

G_STATIC_ASSERT (G_REGEX_ANCHORED          == PCRE_ANCHORED);

G_STATIC_ASSERT (G_REGEX_DOLLAR_ENDONLY    == PCRE_DOLLAR_ENDONLY);

G_STATIC_ASSERT (G_REGEX_UNGREEDY          == PCRE_UNGREEDY);

G_STATIC_ASSERT (G_REGEX_NO_AUTO_CAPTURE   == PCRE_NO_AUTO_CAPTURE);

G_STATIC_ASSERT (G_REGEX_FIRSTLINE         == PCRE_FIRSTLINE);

G_STATIC_ASSERT (G_REGEX_DUPNAMES          == PCRE_DUPNAMES);

G_STATIC_ASSERT (G_REGEX_NEWLINE_CR        == PCRE_NEWLINE_CR);

G_STATIC_ASSERT (G_REGEX_NEWLINE_LF        == PCRE_NEWLINE_LF);

G_STATIC_ASSERT (G_REGEX_NEWLINE_CRLF      == PCRE_NEWLINE_CRLF);

G_STATIC_ASSERT (G_REGEX_NEWLINE_ANYCRLF   == PCRE_NEWLINE_ANYCRLF);

G_STATIC_ASSERT (G_REGEX_BSR_ANYCRLF       == PCRE_BSR_ANYCRLF);

G_STATIC_ASSERT (G_REGEX_JAVASCRIPT_COMPAT == PCRE_JAVASCRIPT_COMPAT);

G_STATIC_ASSERT (G_REGEX_MATCH_ANCHORED         == PCRE_ANCHORED);

G_STATIC_ASSERT (G_REGEX_MATCH_NOTBOL           == PCRE_NOTBOL);

G_STATIC_ASSERT (G_REGEX_MATCH_NOTEOL           == PCRE_NOTEOL);

G_STATIC_ASSERT (G_REGEX_MATCH_NOTEMPTY         == PCRE_NOTEMPTY);

G_STATIC_ASSERT (G_REGEX_MATCH_PARTIAL          == PCRE_PARTIAL);

G_STATIC_ASSERT (G_REGEX_MATCH_NEWLINE_CR       == PCRE_NEWLINE_CR);

G_STATIC_ASSERT (G_REGEX_MATCH_NEWLINE_LF       == PCRE_NEWLINE_LF);

G_STATIC_ASSERT (G_REGEX_MATCH_NEWLINE_CRLF     == PCRE_NEWLINE_CRLF);

G_STATIC_ASSERT (G_REGEX_MATCH_NEWLINE_ANY      == PCRE_NEWLINE_ANY);

G_STATIC_ASSERT (G_REGEX_MATCH_NEWLINE_ANYCRLF  == PCRE_NEWLINE_ANYCRLF);

G_STATIC_ASSERT (G_REGEX_MATCH_BSR_ANYCRLF      == PCRE_BSR_ANYCRLF);

G_STATIC_ASSERT (G_REGEX_MATCH_BSR_ANY          == PCRE_BSR_UNICODE);

G_STATIC_ASSERT (G_REGEX_MATCH_PARTIAL_SOFT     == PCRE_PARTIAL_SOFT);

G_STATIC_ASSERT (G_REGEX_MATCH_PARTIAL_HARD     == PCRE_PARTIAL_HARD);

G_STATIC_ASSERT (G_REGEX_MATCH_NOTEMPTY_ATSTART == PCRE_NOTEMPTY_ATSTART);

/* These PCRE flags are unused or not exposed publically in GRegexFlags, so

 * it should be ok to reuse them for different things.

 */

G_STATIC_ASSERT (G_REGEX_OPTIMIZE          == PCRE_NO_UTF8_CHECK);

G_STATIC_ASSERT (G_REGEX_RAW               == PCRE_UTF8);

/* if the string is in UTF-8 use g_utf8_ functions, else use

 * use just +/- 1. */

#define NEXT_CHAR(re, s) (((re)->compile_opts & G_REGEX_RAW) ? \

                                ((s) + 1) : \

                                g_utf8_next_char (s))

#define PREV_CHAR(re, s) (((re)->compile_opts & G_REGEX_RAW) ? \

                                ((s) - 1) : \

                                g_utf8_prev_char (s))

struct _GMatchInfo

{

  volatile gint ref_count;      /* the ref count */

  GRegex *regex;                /* the regex */

  GRegexMatchFlags match_opts;  /* options used at match time on the regex */

  gint matches;                 /* number of matching sub patterns */

  gint pos;                     /* position in the string where last match left off */

  gint  n_offsets;              /* number of offsets */

  gint *offsets;                /* array of offsets paired 0,1 ; 2,3 ; 3,4 etc */

  gint *workspace;              /* workspace for pcre_dfa_exec() */

  gint n_workspace;             /* number of workspace elements */

  const gchar *string;          /* string passed to the match function */

  gssize string_len;            /* length of string */

};

struct _GRegex

{

  volatile gint ref_count;      /* the ref count for the immutable part */

  gchar *pattern;               /* the pattern */

  pcre *pcre_re;                /* compiled form of the pattern */

  GRegexCompileFlags compile_opts;      /* options used at compile time on the pattern */

  GRegexMatchFlags match_opts;  /* options used at match time on the regex */

  pcre_extra *extra;            /* data stored when G_REGEX_OPTIMIZE is used */

};

/* TRUE if ret is an error code, FALSE otherwise. */

#define IS_PCRE_ERROR(ret) ((ret) < PCRE_ERROR_NOMATCH && (ret) != PCRE_ERROR_PARTIAL)

typedef struct _InterpolationData InterpolationData;

static gboolean  interpolation_list_needs_match (GList *list);

static gboolean  interpolate_replacement        (const GMatchInfo *match_info,

                                                 GString *result,

                                                 gpointer data);

static GList    *split_replacement              (const gchar *replacement,

                                                 GError **error);

static void      free_interpolation_data        (InterpolationData *data);

static const gchar *

match_error (gint errcode)

{

  switch (errcode)

    {

    case PCRE_ERROR_NOMATCH:

      /* not an error */

      break;

    case PCRE_ERROR_NULL:

      /* NULL argument, this should not happen in GRegex */

      g_warning ("A NULL argument was passed to PCRE");

      break;

    case PCRE_ERROR_BADOPTION:

      return "bad options";

    case PCRE_ERROR_BADMAGIC:

      return _("corrupted object");

    case PCRE_ERROR_UNKNOWN_OPCODE:

      return N_("internal error or corrupted object");

    case PCRE_ERROR_NOMEMORY:

      return _("out of memory");

    case PCRE_ERROR_NOSUBSTRING:

      /* not used by pcre_exec() */

      break;

    case PCRE_ERROR_MATCHLIMIT:

      return _("backtracking limit reached");

    case PCRE_ERROR_CALLOUT:

      /* callouts are not implemented */

      break;

    case PCRE_ERROR_BADUTF8:

    case PCRE_ERROR_BADUTF8_OFFSET:

      /* we do not check if strings are valid */

      break;

    case PCRE_ERROR_PARTIAL:

      /* not an error */

      break;

    case PCRE_ERROR_BADPARTIAL:

      return _("the pattern contains items not supported for partial matching");

    case PCRE_ERROR_INTERNAL:

      return _("internal error");

    case PCRE_ERROR_BADCOUNT:

      /* negative ovecsize, this should not happen in GRegex */

      g_warning ("A negative ovecsize was passed to PCRE");

      break;

    case PCRE_ERROR_DFA_UITEM:

      return _("the pattern contains items not supported for partial matching");

    case PCRE_ERROR_DFA_UCOND:

      return _("back references as conditions are not supported for partial matching");

    case PCRE_ERROR_DFA_UMLIMIT:

      /* the match_field field is not used in GRegex */

      break;

    case PCRE_ERROR_DFA_WSSIZE:

      /* handled expanding the workspace */

      break;

    case PCRE_ERROR_DFA_RECURSE:

    case PCRE_ERROR_RECURSIONLIMIT:

      return _("recursion limit reached");

    case PCRE_ERROR_BADNEWLINE:

      return _("invalid combination of newline flags");

    case PCRE_ERROR_BADOFFSET:

      return _("bad offset");

    case PCRE_ERROR_SHORTUTF8:

      return _("short utf8");

    case PCRE_ERROR_RECURSELOOP:

      return _("recursion loop");

    default:

      break;

    }

  return _("unknown error");

}

static void

translate_compile_error (gint *errcode, const gchar **errmsg)

{

  /* Compile errors are created adding 100 to the error code returned

   * by PCRE.

   * If errcode is known we put the translatable error message in

   * erromsg. If errcode is unknown we put the generic

   * G_REGEX_ERROR_COMPILE error code in errcode and keep the

   * untranslated error message returned by PCRE.

   * Note that there can be more PCRE errors with the same GRegexError

   * and that some PCRE errors are useless for us.

   */

  *errcode += 100;

  switch (*errcode)

    {

    case G_REGEX_ERROR_STRAY_BACKSLASH:

      *errmsg = _("\\ at end of pattern");

      break;

    case G_REGEX_ERROR_MISSING_CONTROL_CHAR:

      *errmsg = _("\\c at end of pattern");

      break;

    case G_REGEX_ERROR_UNRECOGNIZED_ESCAPE:

      *errmsg = _("unrecognized character following \\");

      break;

    case G_REGEX_ERROR_QUANTIFIERS_OUT_OF_ORDER:

      *errmsg = _("numbers out of order in {} quantifier");

      break;

    case G_REGEX_ERROR_QUANTIFIER_TOO_BIG:

      *errmsg = _("number too big in {} quantifier");

      break;

    case G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS:

      *errmsg = _("missing terminating ] for character class");

      break;

    case G_REGEX_ERROR_INVALID_ESCAPE_IN_CHARACTER_CLASS:

      *errmsg = _("invalid escape sequence in character class");

      break;

    case G_REGEX_ERROR_RANGE_OUT_OF_ORDER:

      *errmsg = _("range out of order in character class");

      break;

    case G_REGEX_ERROR_NOTHING_TO_REPEAT:

      *errmsg = _("nothing to repeat");

      break;

    case 111: /* internal error: unexpected repeat */

      *errcode = G_REGEX_ERROR_INTERNAL;

      *errmsg = _("unexpected repeat");

      break;

    case G_REGEX_ERROR_UNRECOGNIZED_CHARACTER:

      *errmsg = _("unrecognized character after (? or (?-");

      break;

    case G_REGEX_ERROR_POSIX_NAMED_CLASS_OUTSIDE_CLASS:

      *errmsg = _("POSIX named classes are supported only within a class");

      break;

    case G_REGEX_ERROR_UNMATCHED_PARENTHESIS:

      *errmsg = _("missing terminating )");

      break;

    case G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE:

      *errmsg = _("reference to non-existent subpattern");

      break;

    case G_REGEX_ERROR_UNTERMINATED_COMMENT:

      *errmsg = _("missing ) after comment");

      break;

    case G_REGEX_ERROR_EXPRESSION_TOO_LARGE:

      *errmsg = _("regular expression is too large");

      break;

    case G_REGEX_ERROR_MEMORY_ERROR:

      *errmsg = _("failed to get memory");

      break;

    case 122: /* unmatched parentheses */

      *errcode = G_REGEX_ERROR_UNMATCHED_PARENTHESIS;

      *errmsg = _(") without opening (");

      break;

    case 123: /* internal error: code overflow */

      *errcode = G_REGEX_ERROR_INTERNAL;

      *errmsg = _("code overflow");

      break;

    case 124: /* "unrecognized character after (?<\0 */

      *errcode = G_REGEX_ERROR_UNRECOGNIZED_CHARACTER;

      *errmsg = _("unrecognized character after (?<");

      break;

    case G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND:

      *errmsg = _("lookbehind assertion is not fixed length");

      break;

    case G_REGEX_ERROR_MALFORMED_CONDITION:

      *errmsg = _("malformed number or name after (?(");

      break;

    case G_REGEX_ERROR_TOO_MANY_CONDITIONAL_BRANCHES:

      *errmsg = _("conditional group contains more than two branches");

      break;

    case G_REGEX_ERROR_ASSERTION_EXPECTED:

      *errmsg = _("assertion expected after (?(");

      break;

    case 129:

      *errcode = G_REGEX_ERROR_UNMATCHED_PARENTHESIS;

      /* translators: '(?R' and '(?[+-]digits' are both meant as (groups of)

       * sequences here, '(?-54' would be an example for the second group.

       */

      *errmsg = _("(?R or (?[+-]digits must be followed by )");

      break;

    case G_REGEX_ERROR_UNKNOWN_POSIX_CLASS_NAME:

      *errmsg = _("unknown POSIX class name");

      break;

    case G_REGEX_ERROR_POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED:

      *errmsg = _("POSIX collating elements are not supported");

      break;

    case G_REGEX_ERROR_HEX_CODE_TOO_LARGE:

      *errmsg = _("character value in \\x{...} sequence is too large");

      break;

    case G_REGEX_ERROR_INVALID_CONDITION:

      *errmsg = _("invalid condition (?(0)");

      break;

    case G_REGEX_ERROR_SINGLE_BYTE_MATCH_IN_LOOKBEHIND:

      *errmsg = _("\\C not allowed in lookbehind assertion");

      break;

    case 137: /* PCRE does not support \\L, \\l, \\N{name}, \\U, or \\u\0 */

      /* A number of Perl escapes are not handled by PCRE.

       * Therefore it explicitly raises ERR37.

       */

      *errcode = G_REGEX_ERROR_UNRECOGNIZED_ESCAPE;

      *errmsg = _("escapes \\L, \\l, \\N{name}, \\U, and \\u are not supported");

      break;

    case G_REGEX_ERROR_INFINITE_LOOP:

      *errmsg = _("recursive call could loop indefinitely");

      break;

    case 141: /* unrecognized character after (?P\0 */

      *errcode = G_REGEX_ERROR_UNRECOGNIZED_CHARACTER;

      *errmsg = _("unrecognized character after (?P");

      break;

    case G_REGEX_ERROR_MISSING_SUBPATTERN_NAME_TERMINATOR:

      *errmsg = _("missing terminator in subpattern name");

      break;

    case G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME:

      *errmsg = _("two named subpatterns have the same name");

      break;

    case G_REGEX_ERROR_MALFORMED_PROPERTY:

      *errmsg = _("malformed \\P or \\p sequence");

      break;

    case G_REGEX_ERROR_UNKNOWN_PROPERTY:

      *errmsg = _("unknown property name after \\P or \\p");

      break;

    case G_REGEX_ERROR_SUBPATTERN_NAME_TOO_LONG:

      *errmsg = _("subpattern name is too long (maximum 32 characters)");

      break;

    case G_REGEX_ERROR_TOO_MANY_SUBPATTERNS:

      *errmsg = _("too many named subpatterns (maximum 10,000)");

      break;

    case G_REGEX_ERROR_INVALID_OCTAL_VALUE:

      *errmsg = _("octal value is greater than \\377");

      break;

    case 152: /* internal error: overran compiling workspace */

      *errcode = G_REGEX_ERROR_INTERNAL;

      *errmsg = _("overran compiling workspace");

      break;

    case 153: /* internal error: previously-checked referenced subpattern not found */

      *errcode = G_REGEX_ERROR_INTERNAL;

      *errmsg = _("previously-checked referenced subpattern not found");

      break;

    case G_REGEX_ERROR_TOO_MANY_BRANCHES_IN_DEFINE:

      *errmsg = _("DEFINE group contains more than one branch");

      break;

    case G_REGEX_ERROR_INCONSISTENT_NEWLINE_OPTIONS:

      *errmsg = _("inconsistent NEWLINE options");

      break;

    case G_REGEX_ERROR_MISSING_BACK_REFERENCE:

      *errmsg = _("\\g is not followed by a braced, angle-bracketed, or quoted name or "

                  "number, or by a plain number");

      break;

    case G_REGEX_ERROR_INVALID_RELATIVE_REFERENCE:

      *errmsg = _("a numbered reference must not be zero");

      break;

    case G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN:

      *errmsg = _("an argument is not allowed for (*ACCEPT), (*FAIL), or (*COMMIT)");

      break;

    case G_REGEX_ERROR_UNKNOWN_BACKTRACKING_CONTROL_VERB:

      *errmsg = _("(*VERB) not recognized");

      break;

    case G_REGEX_ERROR_NUMBER_TOO_BIG:

      *errmsg = _("number is too big");

      break;

    case G_REGEX_ERROR_MISSING_SUBPATTERN_NAME:

      *errmsg = _("missing subpattern name after (?&";;

      break;

    case G_REGEX_ERROR_MISSING_DIGIT:

      *errmsg = _("digit expected after (?+");

      break;

    case G_REGEX_ERROR_INVALID_DATA_CHARACTER:

      *errmsg = _("] is an invalid data character in JavaScript compatibility mode");

      break;

    case G_REGEX_ERROR_EXTRA_SUBPATTERN_NAME:

      *errmsg = _("different names for subpatterns of the same number are not allowed");

      break;

    case G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED:

      *errmsg = _("(*MARK) must have an argument");

      break;

    case G_REGEX_ERROR_INVALID_CONTROL_CHAR:

      *errmsg = _( "\\c must be followed by an ASCII character");

      break;

    case G_REGEX_ERROR_MISSING_NAME:

      *errmsg = _("\\k is not followed by a braced, angle-bracketed, or quoted name");

      break;

    case G_REGEX_ERROR_NOT_SUPPORTED_IN_CLASS:

      *errmsg = _("\\N is not supported in a class");

      break;

    case G_REGEX_ERROR_TOO_MANY_FORWARD_REFERENCES:

      *errmsg = _("too many forward references");

      break;

    case G_REGEX_ERROR_NAME_TOO_LONG:

      *errmsg = _("name is too long in (*MARK), (*PRUNE), (*SKIP), or (*THEN)");

      break;

    case G_REGEX_ERROR_CHARACTER_VALUE_TOO_LARGE:

      *errmsg = _("character value in \\u.... sequence is too large");

      break;

    case 116: /* erroffset passed as NULL */

      /* This should not happen as we never pass a NULL erroffset */

      g_warning ("erroffset passed as NULL");

      *errcode = G_REGEX_ERROR_COMPILE;

      break;

    case 117: /* unknown option bit(s) set */

      /* This should not happen as we check options before passing them

       * to pcre_compile2() */

      g_warning ("unknown option bit(s) set");

      *errcode = G_REGEX_ERROR_COMPILE;

      break;

    case 132: /* this version of PCRE is compiled without UTF support */

    case 144: /* invalid UTF-8 string */

    case 145: /* support for \\P, \\p, and \\X has not been compiled */

    case 167: /* this version of PCRE is not compiled with Unicode property support */

    case 173: /* disallowed Unicode code point (>= 0xd800 && <= 0xdfff) */

    case 174: /* invalid UTF-16 string */

      /* These errors should not happen as we are using an UTF-8 and UCP-enabled PCRE

       * and we do not check if strings are valid */

    case 170: /* internal error: unknown opcode in find_fixedlength() */

      *errcode = G_REGEX_ERROR_INTERNAL;

      break;

    default:

      *errcode = G_REGEX_ERROR_COMPILE;

    }

}

/* GMatchInfo */

static GMatchInfo *

match_info_new (const GRegex *regex,

                const gchar  *string,

                gint          string_len,

                gint          start_position,

                gint          match_options,

                gboolean      is_dfa)

{

  GMatchInfo *match_info;

  if (string_len < 0)

    string_len = strlen (string);

  match_info = g_new0 (GMatchInfo, 1);

  match_info->ref_count = 1;

  match_info->regex = g_regex_ref ((GRegex *)regex);

  match_info->string = string;

  match_info->string_len = string_len;

  match_info->matches = PCRE_ERROR_NOMATCH;

  match_info->pos = start_position;

  match_info->match_opts = match_options;

  if (is_dfa)

    {

      /* These values should be enough for most cases, if they are not

       * enough g_regex_match_all_full() will expand them. */

      match_info->n_offsets = 24;

      match_info->n_workspace = 100;

      match_info->workspace = g_new (gint, match_info->n_workspace);

    }

  else

    {

      gint capture_count;

      pcre_fullinfo (regex->pcre_re, regex->extra,

                     PCRE_INFO_CAPTURECOUNT, &capture_count);

      match_info->n_offsets = (capture_count + 1) * 3;

    }

  match_info->offsets = g_new0 (gint, match_info->n_offsets);

  /* Set an invalid position for the previous match. */

  match_info->offsets[0] = -1;

  match_info->offsets[1] = -1;

  return match_info;

}

/**

 * g_match_info_get_regex:

 * @match_info: a #GMatchInfo

 *

 * Returns #GRegex object used in @match_info. It belongs to Glib

 * and must not be freed. Use g_regex_ref() if you need to keep it

 * after you free @match_info object.

 *

 * Returns: #GRegex object used in @match_info

 *

 * Since: 2.14

 */

GRegex *

g_match_info_get_regex (const GMatchInfo *match_info)

{

  g_return_val_if_fail (match_info != NULL, NULL);

  return match_info->regex;

}

/**

 * g_match_info_get_string:

 * @match_info: a #GMatchInfo

 *

 * Returns the string searched with @match_info. This is the

 * string passed to g_regex_match() or g_regex_replace() so

 * you may not free it before calling this function.

 *

 * Returns: the string searched with @match_info

 *

 * Since: 2.14

 */

const gchar *

g_match_info_get_string (const GMatchInfo *match_info)

{

  g_return_val_if_fail (match_info != NULL, NULL);

  return match_info->string;

}

/**

 * g_match_info_ref:

 * @match_info: a #GMatchInfo

 *

 * Increases reference count of @match_info by 1.

 *

 * Returns: @match_info

 *

 * Since: 2.30

 */

GMatchInfo       *

g_match_info_ref (GMatchInfo *match_info)

{

  g_return_val_if_fail (match_info != NULL, NULL);

  g_atomic_int_inc (&match_info->ref_count);

  return match_info;

}

/**

 * g_match_info_unref:

 * @match_info: a #GMatchInfo

 *

 * Decreases reference count of @match_info by 1. When reference count drops

 * to zero, it frees all the memory associated with the match_info structure.

 *

 * Since: 2.30

 */

void

g_match_info_unref (GMatchInfo *match_info)

{

  if (g_atomic_int_dec_and_test (&match_info->ref_count))

    {

      g_regex_unref (match_info->regex);

      g_free (match_info->offsets);

      g_free (match_info->workspace);

      g_free (match_info);

    }

}

/**

 * g_match_info_free:

 * @match_info: (nullable): a #GMatchInfo, or %NULL

 *

 * If @match_info is not %NULL, calls g_match_info_unref(); otherwise does

 * nothing.

 *

 * Since: 2.14

 */

void

g_match_info_free (GMatchInfo *match_info)

{

  if (match_info == NULL)

    return;

  g_match_info_unref (match_info);

}

/**

 * g_match_info_next:

 * @match_info: a #GMatchInfo structure

 * @error: location to store the error occurring, or %NULL to ignore errors

 *

 * Scans for the next match using the same parameters of the previous

 * call to g_regex_match_full() or g_regex_match() that returned

 * @match_info.

 *

 * The match is done on the string passed to the match function, so you

 * cannot free it before calling this function.

 *

 * Returns: %TRUE is the string matched, %FALSE otherwise

 *

 * Since: 2.14

 */

gboolean

g_match_info_next (GMatchInfo  *match_info,

                   GError     **error)

{

  gint prev_match_start;

  gint prev_match_end;

  g_return_val_if_fail (match_info != NULL, FALSE);

  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);

  g_return_val_if_fail (match_info->pos >= 0, FALSE);

  prev_match_start = match_info->offsets[0];

  prev_match_end = match_info->offsets[1];

  if (match_info->pos > match_info->string_len)

    {

      /* we have reached the end of the string */

      match_info->pos = -1;

      match_info->matches = PCRE_ERROR_NOMATCH;

      return FALSE;

    }

  match_info->matches = pcre_exec (match_info->regex->pcre_re,

                                   match_info->regex->extra,

                                   match_info->string,

                                   match_info->string_len,

                                   match_info->pos,

                                   match_info->regex->match_opts | match_info->match_opts,

                                   match_info->offsets,

                                   match_info->n_offsets);

  if (IS_PCRE_ERROR (match_info->matches))

    {

      g_set_error (error, G_REGEX_ERROR, G_REGEX_ERROR_MATCH,

                   _("Error while matching regular expression %s: %s"),

                   match_info->regex->pattern, match_error (match_info->matches));

      return FALSE;

    }

  /* avoid infinite loops if the pattern is an empty string or something

   * equivalent */

  if (match_info->pos == match_info->offsets[1])

    {

      if (match_info->pos > match_info->string_len)

        {

          /* we have reached the end of the string */

          match_info->pos = -1;

          match_info->matches = PCRE_ERROR_NOMATCH;

          return FALSE;

        }

      match_info->pos = NEXT_CHAR (match_info->regex,

                                   &match_info->string[match_info->pos]) -

                                   match_info->string;

    }

  else

    {

      match_info->pos = match_info->offsets[1];

    }

  /* it's possible to get two identical matches when we are matching

   * empty strings, for instance if the pattern is "(?=[A-Z0-9])" and

   * the string is "RegExTest" we have:

   *  - search at position 0: match from 0 to 0

   *  - search at position 1: match from 3 to 3

   *  - search at position 3: match from 3 to 3 (duplicate)

   *  - search at position 4: match from 5 to 5

   *  - search at position 5: match from 5 to 5 (duplicate)

   *  - search at position 6: no match -> stop

   * so we have to ignore the duplicates.

   * see bug #515944: http://bugzilla.gnome.org/show_bug.cgi?id=515944 */

  if (match_info->matches >= 0 &&

      prev_match_start == match_info->offsets[0] &&

      prev_match_end == match_info->offsets[1])

    {

      /* ignore this match and search the next one */

      return g_match_info_next (match_info, error);

    }

  return match_info->matches >= 0;

}

/**

 * g_match_info_matches:

 * @match_info: a #GMatchInfo structure

 *

 * Returns whether the previous match operation succeeded.

 *

 * Returns: %TRUE if the previous match operation succeeded,

 *   %FALSE otherwise

 *

 * Since: 2.14

 */

gboolean

g_match_info_matches (const GMatchInfo *match_info)

{

  g_return_val_if_fail (match_info != NULL, FALSE);

  return match_info->matches >= 0;

}

/**

 * g_match_info_get_match_count:

 * @match_info: a #GMatchInfo structure

 *

 * Retrieves the number of matched substrings (including substring 0,

 * that is the whole matched text), so 1 is returned if the pattern

 * has no substrings in it and 0 is returned if the match failed.

 *

 * If the last match was obtained using the DFA algorithm, that is

 * using g_regex_match_all() or g_regex_match_all_full(), the retrieved

 * count is not that of the number of capturing parentheses but that of

 * the number of matched substrings.

 *

 * Returns: Number of matched substrings, or -1 if an error occurred

 *

 * Since: 2.14

 */

gint

g_match_info_get_match_count (const GMatchInfo *match_info)

{

  g_return_val_if_fail (match_info, -1);

  if (match_info->matches == PCRE_ERROR_NOMATCH)

    /* no match */

    return 0;

  else if (match_info->matches < PCRE_ERROR_NOMATCH)

    /* error */

    return -1;

  else

    /* match */

    return match_info->matches;

}

/**

 * g_match_info_is_partial_match:

 * @match_info: a #GMatchInfo structure

 *

 * Usually if the string passed to g_regex_match*() matches as far as

 * it goes, but is too short to match the entire pattern, %FALSE is

 * returned. There are circumstances where it might be helpful to

 * distinguish this case from other cases in which there is no match.

 *

 * Consider, for example, an application where a human is required to

 * type in data for a field with specific formatting requirements. An

 * example might be a date in the form ddmmmyy, defined by the pattern

 * "^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$".

 * If the application sees the user’s keystrokes one by one, and can

 * check that what has been typed so far is potentially valid, it is

 * able to raise an error as soon as a mistake is made.

 *

 * GRegex supports the concept of partial matching by means of the

 * #G_REGEX_MATCH_PARTIAL_SOFT and #G_REGEX_MATCH_PARTIAL_HARD flags.

 * When they are used, the return code for

 * g_regex_match() or g_regex_match_full() is, as usual, %TRUE

 * for a complete match, %FALSE otherwise. But, when these functions

 * return %FALSE, you can check if the match was partial calling

 * g_match_info_is_partial_match().

 *

 * The difference between #G_REGEX_MATCH_PARTIAL_SOFT and 

 * #G_REGEX_MATCH_PARTIAL_HARD is that when a partial match is encountered

 * with #G_REGEX_MATCH_PARTIAL_SOFT, matching continues to search for a

 * possible complete match, while with #G_REGEX_MATCH_PARTIAL_HARD matching

 * stops at the partial match.

 * When both #G_REGEX_MATCH_PARTIAL_SOFT and #G_REGEX_MATCH_PARTIAL_HARD

 * are set, the latter takes precedence.

 *

 * There were formerly some restrictions on the pattern for partial matching.

 * The restrictions no longer apply.

 *