/* 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>

 * Portions copyright (c) 2009 Nokia Corporation.  All rights reserved.

 * 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, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

#include "config.h"

#include <string.h>

#include "glib.h"

#include "glibintl.h"

#include "gregex.h"

#ifdef USE_SYSTEM_PCRE

#include <pcre.h>

#else

#include "pcre/pcre.h"

#endif

/* PCRE 7.3 does not contain the definition of PCRE_ERROR_NULLWSLIMIT */

#ifndef PCRE_ERROR_NULLWSLIMIT

#define PCRE_ERROR_NULLWSLIMIT (-22)

#endif

#include "galias.h"

#ifdef __SYMBIAN32__

#include "glib_wsd.h"

#endif /* __SYMBIAN32__ */

/* 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_DUPNAMES		| \

			      G_REGEX_NEWLINE_CR	| \

			      G_REGEX_NEWLINE_LF	| \

			      G_REGEX_NEWLINE_CRLF)

/* 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)

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

 * use just +/- 1. */

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

				g_utf8_next_char (s) : \

				((s) + 1))

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

				g_utf8_prev_char (s) : \

				((s) - 1))

struct _GMatchInfo

{

  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 *offsets;		/* array of offsets paired 0,1 ; 2,3 ; 3,4 etc */

  gint n_offsets;		/* number of offsets */

  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_NULLWSLIMIT:

      return _("workspace limit for empty substrings reached");

    case PCRE_ERROR_BADNEWLINE:

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

    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 follows \\");

      break;

    case 137:

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

       * Therefore it explicitly raises ERR37.

       */

      *errcode = G_REGEX_ERROR_UNRECOGNIZED_ESCAPE;

      *errmsg = _("case-changing escapes (\\l, \\L, \\u, \\U) are not allowed here");

      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 G_REGEX_ERROR_UNRECOGNIZED_CHARACTER:

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

      break;

    case 124:

      *errcode = G_REGEX_ERROR_UNRECOGNIZED_CHARACTER;

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

      break;

    case 141:

      *errcode = G_REGEX_ERROR_UNRECOGNIZED_CHARACTER;

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

      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 122:

      *errcode = G_REGEX_ERROR_UNMATCHED_PARENTHESIS;

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

      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_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 too large");

      break;

    case G_REGEX_ERROR_MEMORY_ERROR:

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

      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 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 G_REGEX_ERROR_INFINITE_LOOP:

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

      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 G_REGEX_ERROR_TOO_MANY_BRANCHES_IN_DEFINE:

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

      break;

    case G_REGEX_ERROR_DEFINE_REPETION:

      *errmsg = _("repeating a DEFINE group is not allowed");

      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 name or an optionally "

		 "braced non-zero number");

      break;

    case 11:

      *errcode = G_REGEX_ERROR_INTERNAL;

      *errmsg = _("unexpected repeat");

      break;

    case 23:

      *errcode = G_REGEX_ERROR_INTERNAL;

      *errmsg = _("code overflow");

      break;

    case 52:

      *errcode = G_REGEX_ERROR_INTERNAL;

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

      break;

    case 53:

      *errcode = G_REGEX_ERROR_INTERNAL;

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

      break;

    case 16:

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

      g_warning ("erroffset passed as NULL");

      *errcode = G_REGEX_ERROR_COMPILE;

      break;

    case 17:

      /* 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 32:

    case 44:

    case 45:

      /* These errors should not happen as we are using an UTF8-enabled PCRE

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

      g_warning ("%s", *errmsg);

      *errcode = G_REGEX_ERROR_COMPILE;

      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->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

 */

EXPORT_C 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

 */

EXPORT_C 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_free:

 * @match_info: a #GMatchInfo

 *

 * Frees all the memory associated with the #GMatchInfo structure.

 *

 * Since: 2.14

 */

EXPORT_C void

g_match_info_free (GMatchInfo *match_info)

{

  if (match_info)

    {

      g_regex_unref (match_info->regex);

      g_free (match_info->offsets);

      g_free (match_info->workspace);

      g_free (match_info);

    }

}

/**

 * g_match_info_next:

 * @match_info: a #GMatchInfo structure

 * @error: location to store the error occuring, 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

 */

EXPORT_C gboolean

g_match_info_next (GMatchInfo  *match_info,

		   GError     **error)

{

  gint opts;

  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);

  opts = match_info->regex->match_opts | match_info->match_opts;

  prev_match_start = match_info->offsets[0];

  prev_match_end = match_info->offsets[1];

  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"),