glib/gregex.c

   1 /* GRegex -- regular expression API wrapper around PCRE.
   2  *
   3  * Copyright (C) 1999, 2000 Scott Wimer
   4  * Copyright (C) 2004, Matthias Clasen <mclasen@redhat.com>
   5  * Copyright (C) 2005 - 2007, Marco Barisione <marco@barisione.org>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21
  22 #include "config.h"
  23
  24 #include <string.h>
  25
  26 #include "glib.h"
  27 #include "glibintl.h"
  28 #include "gregex.h"
  29
  30 #ifdef USE_SYSTEM_PCRE
  31 #include <pcre.h>
  32 #else
  33 #include "pcre/pcre.h"
  34 #endif
  35
  36 /* PCRE 7.3 does not contain the definition of PCRE_ERROR_NULLWSLIMIT */
  37 #ifndef PCRE_ERROR_NULLWSLIMIT
  38 #define PCRE_ERROR_NULLWSLIMIT (-22)
  39 #endif
  40
  41 #include "galias.h"
  42
  43 /* Mask of all the possible values for GRegexCompileFlags. */
  44 #define G_REGEX_COMPILE_MASK (G_REGEX_CASELESS          | \
  45                               G_REGEX_MULTILINE         | \
  46                               G_REGEX_DOTALL            | \
  47                               G_REGEX_EXTENDED          | \
  48                               G_REGEX_ANCHORED          | \
  49                               G_REGEX_DOLLAR_ENDONLY    | \
  50                               G_REGEX_UNGREEDY          | \
  51                               G_REGEX_RAW               | \
  52                               G_REGEX_NO_AUTO_CAPTURE   | \
  53                               G_REGEX_OPTIMIZE          | \
  54                               G_REGEX_DUPNAMES          | \
  55                               G_REGEX_NEWLINE_CR        | \
  56                               G_REGEX_NEWLINE_LF        | \
  57                               G_REGEX_NEWLINE_CRLF)
  58
  59 /* Mask of all the possible values for GRegexMatchFlags. */
  60 #define G_REGEX_MATCH_MASK (G_REGEX_MATCH_ANCHORED      | \
  61                             G_REGEX_MATCH_NOTBOL        | \
  62                             G_REGEX_MATCH_NOTEOL        | \
  63                             G_REGEX_MATCH_NOTEMPTY      | \
  64                             G_REGEX_MATCH_PARTIAL       | \
  65                             G_REGEX_MATCH_NEWLINE_CR    | \
  66                             G_REGEX_MATCH_NEWLINE_LF    | \
  67                             G_REGEX_MATCH_NEWLINE_CRLF  | \
  68                             G_REGEX_MATCH_NEWLINE_ANY)
  69
  70 /* if the string is in UTF-8 use g_utf8_ functions, else use
  71  * use just +/- 1. */
  72 #define NEXT_CHAR(re, s) (((re)->compile_opts & PCRE_UTF8) ? \
  73                                 g_utf8_next_char (s) : \
  74                                 ((s) + 1))
  75 #define PREV_CHAR(re, s) (((re)->compile_opts & PCRE_UTF8) ? \
  76                                 g_utf8_prev_char (s) : \
  77                                 ((s) - 1))
  78
  79 struct _GMatchInfo
  80 {
  81   GRegex *regex;                /* the regex */
  82   GRegexMatchFlags match_opts;  /* options used at match time on the regex */
  83   gint matches;                 /* number of matching sub patterns */
  84   gint pos;                     /* position in the string where last match left off */
  85   gint *offsets;                /* array of offsets paired 0,1 ; 2,3 ; 3,4 etc */
  86   gint n_offsets;               /* number of offsets */
  87   gint *workspace;              /* workspace for pcre_dfa_exec() */
  88   gint n_workspace;             /* number of workspace elements */
  89   const gchar *string;          /* string passed to the match function */
  90   gssize string_len;            /* length of string */
  91 };
  92
  93 struct _GRegex
  94 {
  95   volatile gint ref_count;      /* the ref count for the immutable part */
  96   gchar *pattern;               /* the pattern */
  97   pcre *pcre_re;                /* compiled form of the pattern */
  98   GRegexCompileFlags compile_opts;      /* options used at compile time on the pattern */
  99   GRegexMatchFlags match_opts;  /* options used at match time on the regex */
 100   pcre_extra *extra;            /* data stored when G_REGEX_OPTIMIZE is used */
 101 };
 102
 103 /* TRUE if ret is an error code, FALSE otherwise. */
 104 #define IS_PCRE_ERROR(ret) ((ret) < PCRE_ERROR_NOMATCH && (ret) != PCRE_ERROR_PARTIAL)
 105
 106 typedef struct _InterpolationData InterpolationData;
 107 static gboolean  interpolation_list_needs_match (GList *list);
 108 static gboolean  interpolate_replacement        (const GMatchInfo *match_info,
 109                                                  GString *result,
 110                                                  gpointer data);
 111 static GList    *split_replacement              (const gchar *replacement,
 112                                                  GError **error);
 113 static void      free_interpolation_data        (InterpolationData *data);
 114
 115
 116 static const gchar *
 117 match_error (gint errcode)
 118 {
 119   switch (errcode)
 120     {
 121     case PCRE_ERROR_NOMATCH:
 122       /* not an error */
 123       break;
 124     case PCRE_ERROR_NULL:
 125       /* NULL argument, this should not happen in GRegex */
 126       g_warning ("A NULL argument was passed to PCRE");
 127       break;
 128     case PCRE_ERROR_BADOPTION:
 129       return "bad options";
 130     case PCRE_ERROR_BADMAGIC:
 131       return _("corrupted object");
 132     case PCRE_ERROR_UNKNOWN_OPCODE:
 133       return N_("internal error or corrupted object");
 134     case PCRE_ERROR_NOMEMORY:
 135       return _("out of memory");
 136     case PCRE_ERROR_NOSUBSTRING:
 137       /* not used by pcre_exec() */
 138       break;
 139     case PCRE_ERROR_MATCHLIMIT:
 140       return _("backtracking limit reached");
 141     case PCRE_ERROR_CALLOUT:
 142       /* callouts are not implemented */
 143       break;
 144     case PCRE_ERROR_BADUTF8:
 145     case PCRE_ERROR_BADUTF8_OFFSET:
 146       /* we do not check if strings are valid */
 147       break;
 148     case PCRE_ERROR_PARTIAL:
 149       /* not an error */
 150       break;
 151     case PCRE_ERROR_BADPARTIAL:
 152       return _("the pattern contains items not supported for partial matching");
 153     case PCRE_ERROR_INTERNAL:
 154       return _("internal error");
 155     case PCRE_ERROR_BADCOUNT:
 156       /* negative ovecsize, this should not happen in GRegex */
 157       g_warning ("A negative ovecsize was passed to PCRE");
 158       break;
 159     case PCRE_ERROR_DFA_UITEM:
 160       return _("the pattern contains items not supported for partial matching");
 161     case PCRE_ERROR_DFA_UCOND:
 162       return _("back references as conditions are not supported for partial matching");
 163     case PCRE_ERROR_DFA_UMLIMIT:
 164       /* the match_field field is not used in GRegex */
 165       break;
 166     case PCRE_ERROR_DFA_WSSIZE:
 167       /* handled expanding the workspace */
 168       break;
 169     case PCRE_ERROR_DFA_RECURSE:
 170     case PCRE_ERROR_RECURSIONLIMIT:
 171       return _("recursion limit reached");
 172     case PCRE_ERROR_NULLWSLIMIT:
 173       return _("workspace limit for empty substrings reached");
 174     case PCRE_ERROR_BADNEWLINE:
 175       return _("invalid combination of newline flags");
 176     default:
 177       break;
 178     }
 179   return _("unknown error");
 180 }
 181
 182
 183 /* GMatchInfo */
 184
 185 static GMatchInfo *
 186 match_info_new (const GRegex *regex,
 187                 const gchar  *string,
 188                 gint          string_len,
 189                 gint          start_position,
 190                 gint          match_options,
 191                 gboolean      is_dfa)
 192 {
 193   GMatchInfo *match_info;
 194
 195   if (string_len < 0)
 196     string_len = strlen (string);
 197
 198   match_info = g_new0 (GMatchInfo, 1);
 199   match_info->regex = g_regex_ref ((GRegex *)regex);
 200   match_info->string = string;
 201   match_info->string_len = string_len;
 202   match_info->matches = PCRE_ERROR_NOMATCH;
 203   match_info->pos = start_position;
 204   match_info->match_opts = match_options;
 205
 206   if (is_dfa)
 207     {
 208       /* These values should be enough for most cases, if they are not
 209        * enough g_regex_match_all_full() will expand them. */
 210       match_info->n_offsets = 24;
 211       match_info->n_workspace = 100;
 212       match_info->workspace = g_new (gint, match_info->n_workspace);
 213     }
 214   else
 215     {
 216       gint capture_count;
 217       pcre_fullinfo (regex->pcre_re, regex->extra,
 218                      PCRE_INFO_CAPTURECOUNT, &capture_count);
 219       match_info->n_offsets = (capture_count + 1) * 3;
 220     }
 221   match_info->offsets = g_new0 (gint, match_info->n_offsets);
 222
 223   return match_info;
 224 }
 225
 226 /**
 227  * g_match_info_get_regex:
 228  * @match_info: a #GMatchInfo
 229  *
 230  * Returns #GRegex object used in @match_info. It belongs to Glib
 231  * and must not be freed. Use g_regex_ref() if you need to keep it
 232  * after you free @match_info object.
 233  *
 234  * Returns: #GRegex object used in @match_info
 235  *
 236  * Since: 2.14
 237  */
 238 GRegex *
 239 g_match_info_get_regex (const GMatchInfo *match_info)
 240 {
 241   g_return_val_if_fail (match_info != NULL, NULL);
 242   return match_info->regex;
 243 }
 244
 245 /**
 246  * g_match_info_get_string:
 247  * @match_info: a #GMatchInfo
 248  *
 249  * Returns the string searched with @match_info. This is the
 250  * string passed to g_regex_match() or g_regex_replace() so
 251  * you may not free it before calling this function.
 252  *
 253  * Returns: the string searched with @match_info
 254  *
 255  * Since: 2.14
 256  */
 257 const gchar *
 258 g_match_info_get_string (const GMatchInfo *match_info)
 259 {
 260   g_return_val_if_fail (match_info != NULL, NULL);
 261   return match_info->string;
 262 }
 263
 264 /**
 265  * g_match_info_free:
 266  * @match_info: a #GMatchInfo
 267  *
 268  * Frees all the memory associated with the #GMatchInfo structure.
 269  *
 270  * Since: 2.14
 271  */
 272 void
 273 g_match_info_free (GMatchInfo *match_info)
 274 {
 275   if (match_info)
 276     {
 277       g_regex_unref (match_info->regex);
 278       g_free (match_info->offsets);
 279       g_free (match_info->workspace);
 280       g_free (match_info);
 281     }
 282 }
 283
 284 /**
 285  * g_match_info_next:
 286  * @match_info: a #GMatchInfo structure
 287  * @error: location to store the error occuring, or %NULL to ignore errors
 288  *
 289  * Scans for the next match using the same parameters of the previous
 290  * call to g_regex_match_full() or g_regex_match() that returned
 291  * @match_info.
 292  *
 293  * The match is done on the string passed to the match function, so you
 294  * cannot free it before calling this function.
 295  *
 296  * Returns: %TRUE is the string matched, %FALSE otherwise
 297  *
 298  * Since: 2.14
 299  */
 300 gboolean
 301 g_match_info_next (GMatchInfo  *match_info,
 302                    GError     **error)
 303 {
 304   gint opts;
 305
 306   g_return_val_if_fail (match_info != NULL, FALSE);
 307   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 308   g_return_val_if_fail (match_info->pos >= 0, FALSE);
 309
 310   opts = match_info->regex->match_opts | match_info->match_opts;
 311
 312   match_info->matches = pcre_exec (match_info->regex->pcre_re,
 313                                    match_info->regex->extra,
 314                                    match_info->string,
 315                                    match_info->string_len,
 316                                    match_info->pos,
 317                                    match_info->regex->match_opts |
 318                                    match_info->match_opts,
 319                                    match_info->offsets,
 320                                    match_info->n_offsets);
 321   if (IS_PCRE_ERROR (match_info->matches))
 322     {
 323       g_set_error (error, G_REGEX_ERROR, G_REGEX_ERROR_MATCH,
 324                    _("Error while matching regular expression %s: %s"),
 325                    match_info->regex->pattern, match_error (match_info->matches));
 326       return FALSE;
 327     }
 328
 329   /* avoid infinite loops if the pattern is an empty string or something
 330    * equivalent */
 331   if (match_info->pos == match_info->offsets[1])
 332     {
 333       if (match_info->pos > match_info->string_len)
 334         {
 335           /* we have reached the end of the string */
 336           match_info->pos = -1;
 337           match_info->matches = PCRE_ERROR_NOMATCH;
 338           return FALSE;
 339         }
 340
 341       match_info->pos = NEXT_CHAR (match_info->regex,
 342                                    &match_info->string[match_info->pos]) -
 343                                    match_info->string;
 344     }
 345   else
 346     {
 347       match_info->pos = match_info->offsets[1];
 348     }
 349
 350   return match_info->matches >= 0;
 351 }
 352
 353 /**
 354  * g_match_info_matches:
 355  * @match_info: a #GMatchInfo structure
 356  *
 357  * Returns whether the previous match operation succeeded.
 358  *
 359  * Returns: %TRUE if the previous match operation succeeded,
 360  *   %FALSE otherwise
 361  *
 362  * Since: 2.14
 363  */
 364 gboolean
 365 g_match_info_matches (const GMatchInfo *match_info)
 366 {
 367   g_return_val_if_fail (match_info != NULL, FALSE);
 368
 369   return match_info->matches >= 0;
 370 }
 371
 372 /**
 373  * g_match_info_get_match_count:
 374  * @match_info: a #GMatchInfo structure
 375  *
 376  * Retrieves the number of matched substrings (including substring 0,
 377  * that is the whole matched text), so 1 is returned if the pattern
 378  * has no substrings in it and 0 is returned if the match failed.
 379  *
 380  * If the last match was obtained using the DFA algorithm, that is
 381  * using g_regex_match_all() or g_regex_match_all_full(), the retrieved
 382  * count is not that of the number of capturing parentheses but that of
 383  * the number of matched substrings.
 384  *
 385  * Returns: Number of matched substrings, or -1 if an error occurred
 386  *
 387  * Since: 2.14
 388  */
 389 gint
 390 g_match_info_get_match_count (const GMatchInfo *match_info)
 391 {
 392   g_return_val_if_fail (match_info, -1);
 393
 394   if (match_info->matches == PCRE_ERROR_NOMATCH)
 395     /* no match */
 396     return 0;
 397   else if (match_info->matches < PCRE_ERROR_NOMATCH)
 398     /* error */
 399     return -1;
 400   else
 401     /* match */
 402     return match_info->matches;
 403 }
 404
 405 /**
 406  * g_match_info_is_partial_match:
 407  * @match_info: a #GMatchInfo structure
 408  *
 409  * Usually if the string passed to g_regex_match*() matches as far as
 410  * it goes, but is too short to match the entire pattern, %FALSE is
 411  * returned. There are circumstances where it might be helpful to
 412  * distinguish this case from other cases in which there is no match.
 413  *
 414  * Consider, for example, an application where a human is required to
 415  * type in data for a field with specific formatting requirements. An
 416  * example might be a date in the form ddmmmyy, defined by the pattern
 417  * "^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$".
 418  * If the application sees the user’s keystrokes one by one, and can
 419  * check that what has been typed so far is potentially valid, it is
 420  * able to raise an error as soon as a mistake is made.
 421  *
 422  * GRegex supports the concept of partial matching by means of the
 423  * #G_REGEX_MATCH_PARTIAL flag. When this is set the return code for
 424  * g_regex_match() or g_regex_match_full() is, as usual, %TRUE
 425  * for a complete match, %FALSE otherwise. But, when these functions
 426  * return %FALSE, you can check if the match was partial calling
 427  * g_match_info_is_partial_match().
 428  *
 429  * When using partial matching you cannot use g_match_info_fetch*().
 430  *
 431  * Because of the way certain internal optimizations are implemented
 432  * the partial matching algorithm cannot be used with all patterns.
 433  * So repeated single characters such as "a{2,4}" and repeated single
 434  * meta-sequences such as "\d+" are not permitted if the maximum number
 435  * of occurrences is greater than one. Optional items such as "\d?"
 436  * (where the maximum is one) are permitted. Quantifiers with any values
 437  * are permitted after parentheses, so the invalid examples above can be
 438  * coded thus "(a){2,4}" and "(\d)+". If #G_REGEX_MATCH_PARTIAL is set
 439  * for a pattern that does not conform to the restrictions, matching
 440  * functions return an error.
 441  *
 442  * Returns: %TRUE if the match was partial, %FALSE otherwise
 443  *
 444  * Since: 2.14
 445  */
 446 gboolean
 447 g_match_info_is_partial_match (const GMatchInfo *match_info)
 448 {
 449   g_return_val_if_fail (match_info != NULL, FALSE);
 450
 451   return match_info->matches == PCRE_ERROR_PARTIAL;
 452 }
 453
 454 /**
 455  * g_match_info_expand_references:
 456  * @match_info: a #GMatchInfo or %NULL
 457  * @string_to_expand: the string to expand
 458  * @error: location to store the error occuring, or %NULL to ignore errors
 459  *
 460  * Returns a new string containing the text in @string_to_expand with
 461  * references and escape sequences expanded. References refer to the last
 462  * match done with @string against @regex and have the same syntax used by
 463  * g_regex_replace().
 464  *
 465  * The @string_to_expand must be UTF-8 encoded even if #G_REGEX_RAW was
 466  * passed to g_regex_new().
 467  *
 468  * The backreferences are extracted from the string passed to the match
 469  * function, so you cannot call this function after freeing the string.
 470  *
 471  * @match_info may be %NULL in which case @string_to_expand must not
 472  * contain references. For instance "foo\n" does not refer to an actual
 473  * pattern and '\n' merely will be replaced with \n character,
 474  * while to expand "\0" (whole match) one needs the result of a match.
 475  * Use g_regex_check_replacement() to find out whether @string_to_expand
 476  * contains references.
 477  *
 478  * Returns: the expanded string, or %NULL if an error occurred
 479  *
 480  * Since: 2.14
 481  */
 482 gchar *
 483 g_match_info_expand_references (const GMatchInfo  *match_info,
 484                                 const gchar       *string_to_expand,
 485                                 GError           **error)
 486 {
 487   GString *result;
 488   GList *list;
 489   GError *tmp_error = NULL;
 490
 491   g_return_val_if_fail (string_to_expand != NULL, NULL);
 492   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 493
 494   list = split_replacement (string_to_expand, &tmp_error);
 495   if (tmp_error != NULL)
 496     {
 497       g_propagate_error (error, tmp_error);
 498       return NULL;
 499     }
 500
 501   if (!match_info && interpolation_list_needs_match (list))
 502     {
 503       g_critical ("String '%s' contains references to the match, can't "
 504                   "expand references without GMatchInfo object",
 505                   string_to_expand);
 506       return NULL;
 507     }
 508
 509   result = g_string_sized_new (strlen (string_to_expand));
 510   interpolate_replacement (match_info, result, list);
 511
 512   g_list_foreach (list, (GFunc)free_interpolation_data, NULL);
 513   g_list_free (list);
 514
 515   return g_string_free (result, FALSE);
 516 }
 517
 518 /**
 519  * g_match_info_fetch:
 520  * @match_info: #GMatchInfo structure
 521  * @match_num: number of the sub expression
 522  *
 523  * Retrieves the text matching the @match_num<!-- -->'th capturing
 524  * parentheses. 0 is the full text of the match, 1 is the first paren
 525  * set, 2 the second, and so on.
 526  *
 527  * If @match_num is a valid sub pattern but it didn't match anything
 528  * (e.g. sub pattern 1, matching "b" against "(a)?b") then an empty
 529  * string is returned.
 530  *
 531  * If the match was obtained using the DFA algorithm, that is using
 532  * g_regex_match_all() or g_regex_match_all_full(), the retrieved
 533  * string is not that of a set of parentheses but that of a matched
 534  * substring. Substrings are matched in reverse order of length, so
 535  * 0 is the longest match.
 536  *
 537  * The string is fetched from the string passed to the match function,
 538  * so you cannot call this function after freeing the string.
 539  *
 540  * Returns: The matched substring, or %NULL if an error occurred.
 541  *          You have to free the string yourself
 542  *
 543  * Since: 2.14
 544  */
 545 gchar *
 546 g_match_info_fetch (const GMatchInfo *match_info,
 547                     gint              match_num)
 548 {
 549   /* we cannot use pcre_get_substring() because it allocates the
 550    * string using pcre_malloc(). */
 551   gchar *match = NULL;
 552   gint start, end;
 553
 554   g_return_val_if_fail (match_info != NULL, NULL);
 555   g_return_val_if_fail (match_num >= 0, NULL);
 556
 557   /* match_num does not exist or it didn't matched, i.e. matching "b"
 558    * against "(a)?b" then group 0 is empty. */
 559   if (!g_match_info_fetch_pos (match_info, match_num, &start, &end))
 560     match = NULL;
 561   else if (start == -1)
 562     match = g_strdup ("");
 563   else
 564     match = g_strndup (&match_info->string[start], end - start);
 565
 566   return match;
 567 }
 568
 569 /**
 570  * g_match_info_fetch_pos:
 571  * @match_info: #GMatchInfo structure
 572  * @match_num: number of the sub expression
 573  * @start_pos: pointer to location where to store the start position
 574  * @end_pos: pointer to location where to store the end position
 575  *
 576  * Retrieves the position of the @match_num<!-- -->'th capturing
 577  * parentheses. 0 is the full text of the match, 1 is the first
 578  * paren set, 2 the second, and so on.
 579  *
 580  * If @match_num is a valid sub pattern but it didn't match anything
 581  * (e.g. sub pattern 1, matching "b" against "(a)?b") then @start_pos
 582  * and @end_pos are set to -1 and %TRUE is returned.
 583  *
 584  * If the match was obtained using the DFA algorithm, that is using
 585  * g_regex_match_all() or g_regex_match_all_full(), the retrieved
 586  * position is not that of a set of parentheses but that of a matched
 587  * substring. Substrings are matched in reverse order of length, so
 588  * 0 is the longest match.
 589  *
 590  * Returns: %TRUE if the position was fetched, %FALSE otherwise. If
 591  *   the position cannot be fetched, @start_pos and @end_pos are left
 592  *   unchanged
 593  *
 594  * Since: 2.14
 595  */
 596 gboolean
 597 g_match_info_fetch_pos (const GMatchInfo *match_info,
 598                         gint              match_num,
 599                         gint             *start_pos,
 600                         gint             *end_pos)
 601 {
 602   g_return_val_if_fail (match_info != NULL, FALSE);
 603   g_return_val_if_fail (match_num >= 0, FALSE);
 604
 605   /* make sure the sub expression number they're requesting is less than
 606    * the total number of sub expressions that were matched. */
 607   if (match_num >= match_info->matches)
 608     return FALSE;
 609
 610   if (start_pos != NULL)
 611     *start_pos = match_info->offsets[2 * match_num];
 612
 613   if (end_pos != NULL)
 614     *end_pos = match_info->offsets[2 * match_num + 1];
 615
 616   return TRUE;
 617 }
 618
 619 /*
 620  * Returns number of first matched subpattern with name @name.
 621  * There may be more than one in case when DUPNAMES is used,
 622  * and not all subpatterns with that name match;
 623  * pcre_get_stringnumber() does not work in that case.
 624  */
 625 static gint
 626 get_matched_substring_number (const GMatchInfo *match_info,
 627                               const gchar      *name)
 628 {
 629   gint entrysize;
 630   gchar *first, *last;
 631   guchar *entry;
 632
 633   if (!(match_info->regex->compile_opts & G_REGEX_DUPNAMES))
 634     return pcre_get_stringnumber (match_info->regex->pcre_re, name);
 635
 636   /* This code is copied from pcre_get.c: get_first_set() */
 637   entrysize = pcre_get_stringtable_entries (match_info->regex->pcre_re,
 638                                             name,
 639                                             &first,
 640                                             &last);
 641
 642   if (entrysize <= 0)
 643     return entrysize;
 644
 645   for (entry = (guchar*) first; entry <= (guchar*) last; entry += entrysize)
 646     {
 647       gint n = (entry[0] << 8) + entry[1];
 648       if (match_info->offsets[n*2] >= 0)
 649         return n;
 650     }
 651
 652   return (first[0] << 8) + first[1];
 653 }
 654
 655 /**
 656  * g_match_info_fetch_named:
 657  * @match_info: #GMatchInfo structure
 658  * @name: name of the subexpression
 659  *
 660  * Retrieves the text matching the capturing parentheses named @name.
 661  *
 662  * If @name is a valid sub pattern name but it didn't match anything
 663  * (e.g. sub pattern "X", matching "b" against "(?P&lt;X&gt;a)?b")
 664  * then an empty string is returned.
 665  *
 666  * The string is fetched from the string passed to the match function,
 667  * so you cannot call this function after freeing the string.
 668  *
 669  * Returns: The matched substring, or %NULL if an error occurred.
 670  *          You have to free the string yourself
 671  *
 672  * Since: 2.14
 673  */
 674 gchar *
 675 g_match_info_fetch_named (const GMatchInfo *match_info,
 676                           const gchar      *name)
 677 {
 678   /* we cannot use pcre_get_named_substring() because it allocates the
 679    * string using pcre_malloc(). */
 680   gint num;
 681
 682   g_return_val_if_fail (match_info != NULL, NULL);
 683   g_return_val_if_fail (name != NULL, NULL);
 684
 685   num = get_matched_substring_number (match_info, name);
 686   if (num < 0)
 687     return NULL;
 688   else
 689     return g_match_info_fetch (match_info, num);
 690 }
 691
 692 /**
 693  * g_match_info_fetch_named_pos:
 694  * @match_info: #GMatchInfo structure
 695  * @name: name of the subexpression
 696  * @start_pos: pointer to location where to store the start position
 697  * @end_pos: pointer to location where to store the end position
 698  *
 699  * Retrieves the position of the capturing parentheses named @name.
 700  *
 701  * If @name is a valid sub pattern name but it didn't match anything
 702  * (e.g. sub pattern "X", matching "b" against "(?P&lt;X&gt;a)?b")
 703  * then @start_pos and @end_pos are set to -1 and %TRUE is returned.
 704  *
 705  * Returns: %TRUE if the position was fetched, %FALSE otherwise. If
 706  *   the position cannot be fetched, @start_pos and @end_pos are left
 707  *   unchanged
 708  *
 709  * Since: 2.14
 710  */
 711 gboolean
 712 g_match_info_fetch_named_pos (const GMatchInfo *match_info,
 713                               const gchar      *name,
 714                               gint             *start_pos,
 715                               gint             *end_pos)
 716 {
 717   gint num;
 718
 719   g_return_val_if_fail (match_info != NULL, FALSE);
 720   g_return_val_if_fail (name != NULL, FALSE);
 721
 722   num = get_matched_substring_number (match_info, name);
 723   if (num < 0)
 724     return FALSE;
 725
 726   return g_match_info_fetch_pos (match_info, num, start_pos, end_pos);
 727 }
 728
 729 /**
 730  * g_match_info_fetch_all:
 731  * @match_info: a #GMatchInfo structure
 732  *
 733  * Bundles up pointers to each of the matching substrings from a match
 734  * and stores them in an array of gchar pointers. The first element in
 735  * the returned array is the match number 0, i.e. the entire matched
 736  * text.
 737  *
 738  * If a sub pattern didn't match anything (e.g. sub pattern 1, matching
 739  * "b" against "(a)?b") then an empty string is inserted.
 740  *
 741  * If the last match was obtained using the DFA algorithm, that is using
 742  * g_regex_match_all() or g_regex_match_all_full(), the retrieved
 743  * strings are not that matched by sets of parentheses but that of the
 744  * matched substring. Substrings are matched in reverse order of length,
 745  * so the first one is the longest match.
 746  *
 747  * The strings are fetched from the string passed to the match function,
 748  * so you cannot call this function after freeing the string.
 749  *
 750  * Returns: a %NULL-terminated array of gchar * pointers. It must be
 751  *   freed using g_strfreev(). If the previous match failed %NULL is
 752  *   returned
 753  *
 754  * Since: 2.14
 755  */
 756 gchar **
 757 g_match_info_fetch_all (const GMatchInfo *match_info)
 758 {
 759   /* we cannot use pcre_get_substring_list() because the returned value
 760    * isn't suitable for g_strfreev(). */
 761   gchar **result;
 762   gint i;
 763
 764   g_return_val_if_fail (match_info != NULL, FALSE);
 765
 766   if (match_info->matches < 0)
 767     return NULL;
 768
 769   result = g_new (gchar *, match_info->matches + 1);
 770   for (i = 0; i < match_info->matches; i++)
 771     result[i] = g_match_info_fetch (match_info, i);
 772   result[i] = NULL;
 773
 774   return result;
 775 }
 776
 777
 778 /* GRegex */
 779
 780 GQuark
 781 g_regex_error_quark (void)
 782 {
 783   static GQuark error_quark = 0;
 784
 785   if (error_quark == 0)
 786     error_quark = g_quark_from_static_string ("g-regex-error-quark");
 787
 788   return error_quark;
 789 }
 790
 791 /**
 792  * g_regex_ref:
 793  * @regex: a #GRegex
 794  *
 795  * Increases reference count of @regex by 1.
 796  *
 797  * Returns: @regex
 798  *
 799  * Since: 2.14
 800  */
 801 GRegex *
 802 g_regex_ref (GRegex *regex)
 803 {
 804   g_return_val_if_fail (regex != NULL, NULL);
 805   g_atomic_int_inc (&regex->ref_count);
 806   return regex;
 807 }
 808
 809 /**
 810  * g_regex_unref:
 811  * @regex: a #GRegex
 812  *
 813  * Decreases reference count of @regex by 1. When reference count drops
 814  * to zero, it frees all the memory associated with the regex structure.
 815  *
 816  * Since: 2.14
 817  */
 818 void
 819 g_regex_unref (GRegex *regex)
 820 {
 821   g_return_if_fail (regex != NULL);
 822
 823   if (g_atomic_int_exchange_and_add (&regex->ref_count, -1) - 1 == 0)
 824     {
 825       g_free (regex->pattern);
 826       if (regex->pcre_re != NULL)
 827         pcre_free (regex->pcre_re);
 828       if (regex->extra != NULL)
 829         pcre_free (regex->extra);
 830       g_free (regex);
 831     }
 832 }
 833
 834 /**
 835  * g_regex_new:
 836  * @pattern: the regular expression
 837  * @compile_options: compile options for the regular expression
 838  * @match_options: match options for the regular expression
 839  * @error: return location for a #GError
 840  *
 841  * Compiles the regular expression to an internal form, and does
 842  * the initial setup of the #GRegex structure.
 843  *
 844  * Returns: a #GRegex structure. Call g_regex_unref() when you
 845  *   are done with it
 846  *
 847  * Since: 2.14
 848  */
 849 GRegex *
 850 g_regex_new (const gchar         *pattern,
 851              GRegexCompileFlags   compile_options,
 852              GRegexMatchFlags     match_options,
 853              GError             **error)
 854 {
 855   GRegex *regex;
 856   pcre *re;
 857   const gchar *errmsg;
 858   gint erroffset;
 859   gboolean optimize = FALSE;
 860   static gboolean initialized = FALSE;
 861
 862   g_return_val_if_fail (pattern != NULL, NULL);
 863   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 864   g_return_val_if_fail ((compile_options & ~G_REGEX_COMPILE_MASK) == 0, NULL);
 865   g_return_val_if_fail ((match_options & ~G_REGEX_MATCH_MASK) == 0, NULL);
 866
 867   if (!initialized)
 868     {
 869       gint support;
 870       const gchar *msg;
 871
 872       pcre_config (PCRE_CONFIG_UTF8, &support);
 873       if (!support)
 874         {
 875           msg = N_("PCRE library is compiled without UTF8 support");
 876           g_critical (msg);
 877           g_set_error (error, G_REGEX_ERROR, G_REGEX_ERROR_COMPILE, gettext (msg));
 878           return NULL;
 879         }
 880
 881       pcre_config (PCRE_CONFIG_UNICODE_PROPERTIES, &support);
 882       if (!support)
 883         {
 884           msg = N_("PCRE library is compiled without UTF8 properties support");
 885           g_critical (msg);
 886           g_set_error (error, G_REGEX_ERROR, G_REGEX_ERROR_COMPILE, gettext (msg));
 887           return NULL;
 888         }
 889
 890       initialized = TRUE;
 891     }
 892
 893   /* G_REGEX_OPTIMIZE has the same numeric value of PCRE_NO_UTF8_CHECK,
 894    * as we do not need to wrap PCRE_NO_UTF8_CHECK. */
 895   if (compile_options & G_REGEX_OPTIMIZE)
 896     optimize = TRUE;
 897
 898   /* In GRegex the string are, by default, UTF-8 encoded. PCRE
 899    * instead uses UTF-8 only if required with PCRE_UTF8. */
 900   if (compile_options & G_REGEX_RAW)
 901     {
 902       /* disable utf-8 */
 903       compile_options &= ~G_REGEX_RAW;
 904     }
 905   else
 906     {
 907       /* enable utf-8 */
 908       compile_options |= PCRE_UTF8 | PCRE_NO_UTF8_CHECK;
 909       match_options |= PCRE_NO_UTF8_CHECK;
 910     }
 911
 912   /* PCRE_NEWLINE_ANY is the default for the internal PCRE but
 913    * not for the system one. */
 914   if (!(compile_options & G_REGEX_NEWLINE_CR) &&
 915       !(compile_options & G_REGEX_NEWLINE_LF))
 916     {
 917       compile_options |= PCRE_NEWLINE_ANY;
 918     }
 919
 920   /* compile the pattern */
 921   re = pcre_compile (pattern, compile_options, &errmsg, &erroffset, NULL);
 922
 923   /* if the compilation failed, set the error member and return
 924    * immediately */
 925   if (re == NULL)
 926     {
 927       GError *tmp_error = g_error_new (G_REGEX_ERROR,
 928                                        G_REGEX_ERROR_COMPILE,
 929                                        _("Error while compiling regular "
 930                                          "expression %s at char %d: %s"),
 931                                        pattern, erroffset, errmsg);
 932       g_propagate_error (error, tmp_error);
 933
 934       return NULL;
 935     }
 936
 937   /* For options set at the beginning of the pattern, pcre puts them into
 938    * compile options, e.g. "(?i)foo" will make the pcre structure store
 939    * PCRE_CASELESS even though it wasn't explicitly given for compilation. */
 940   pcre_fullinfo (re, NULL, PCRE_INFO_OPTIONS, &compile_options);
 941
 942   if (!(compile_options & G_REGEX_DUPNAMES))
 943     {
 944       gboolean jchanged = FALSE;
 945       pcre_fullinfo (re, NULL, PCRE_INFO_JCHANGED, &jchanged);
 946       if (jchanged)
 947         compile_options |= G_REGEX_DUPNAMES;
 948     }
 949
 950   regex = g_new0 (GRegex, 1);
 951   regex->ref_count = 1;
 952   regex->pattern = g_strdup (pattern);
 953   regex->pcre_re = re;
 954   regex->compile_opts = compile_options;
 955   regex->match_opts = match_options;
 956
 957   if (optimize)
 958     {
 959       regex->extra = pcre_study (regex->pcre_re, 0, &errmsg);
 960       if (errmsg != NULL)
 961         {
 962           GError *tmp_error = g_error_new (G_REGEX_ERROR,
 963                                            G_REGEX_ERROR_OPTIMIZE,
 964                                            _("Error while optimizing "
 965                                              "regular expression %s: %s"),
 966                                            regex->pattern,
 967                                            errmsg);
 968           g_propagate_error (error, tmp_error);
 969           return NULL;
 970         }
 971     }
 972
 973   return regex;
 974 }
 975
 976 /**
 977  * g_regex_get_pattern:
 978  * @regex: a #GRegex structure
 979  *
 980  * Gets the pattern string associated with @regex, i.e. a copy of
 981  * the string passed to g_regex_new().
 982  *
 983  * Returns: the pattern of @regex
 984  *
 985  * Since: 2.14
 986  */
 987 const gchar *
 988 g_regex_get_pattern (const GRegex *regex)
 989 {
 990   g_return_val_if_fail (regex != NULL, NULL);
 991
 992   return regex->pattern;
 993 }
 994
 995 /**
 996  * g_regex_get_max_backref:
 997  * @regex: a #GRegex
 998  *
 999  * Returns the number of the highest back reference
1000  * in the pattern, or 0 if the pattern does not contain
1001  * back references.
1002  *
1003  * Returns: the number of the highest back reference
1004  *
1005  * Since: 2.14
1006  */
1007 gint
1008 g_regex_get_max_backref (const GRegex *regex)
1009 {
1010   gint value;
1011
1012   pcre_fullinfo (regex->pcre_re, regex->extra,
1013                  PCRE_INFO_BACKREFMAX, &value);
1014
1015   return value;
1016 }
1017
1018 /**
1019  * g_regex_get_capture_count:
1020  * @regex: a #GRegex
1021  *
1022  * Returns the number of capturing subpatterns in the pattern.
1023  *
1024  * Returns: the number of capturing subpatterns
1025  *
1026  * Since: 2.14
1027  */
1028 gint
1029 g_regex_get_capture_count (const GRegex *regex)
1030 {
1031   gint value;
1032
1033   pcre_fullinfo (regex->pcre_re, regex->extra,
1034                  PCRE_INFO_CAPTURECOUNT, &value);
1035
1036   return value;
1037 }
1038
1039 /**
1040  * g_regex_match_simple:
1041  * @pattern: the regular expression
1042  * @string: the string to scan for matches
1043  * @compile_options: compile options for the regular expression
1044  * @match_options: match options
1045  *
1046  * Scans for a match in @string for @pattern.
1047  *
1048  * This function is equivalent to g_regex_match() but it does not
1049  * require to compile the pattern with g_regex_new(), avoiding some
1050  * lines of code when you need just to do a match without extracting
1051  * substrings, capture counts, and so on.
1052  *
1053  * If this function is to be called on the same @pattern more than
1054  * once, it's more efficient to compile the pattern once with
1055  * g_regex_new() and then use g_regex_match().
1056  *
1057  * Returns: %TRUE is the string matched, %FALSE otherwise
1058  *
1059  * Since: 2.14
1060  */
1061 gboolean
1062 g_regex_match_simple (const gchar        *pattern,
1063                       const gchar        *string,
1064                       GRegexCompileFlags  compile_options,
1065                       GRegexMatchFlags    match_options)
1066 {
1067   GRegex *regex;
1068   gboolean result;
1069
1070   regex = g_regex_new (pattern, compile_options, 0, NULL);
1071   if (!regex)
1072     return FALSE;
1073   result = g_regex_match_full (regex, string, -1, 0, match_options, NULL, NULL);
1074   g_regex_unref (regex);
1075   return result;
1076 }
1077
1078 /**
1079  * g_regex_match:
1080  * @regex: a #GRegex structure from g_regex_new()
1081  * @string: the string to scan for matches
1082  * @match_options: match options
1083  * @match_info: pointer to location where to store the #GMatchInfo,
1084  *   or %NULL if you do not need it
1085  *
1086  * Scans for a match in string for the pattern in @regex.
1087  * The @match_options are combined with the match options specified
1088  * when the @regex structure was created, letting you have more
1089  * flexibility in reusing #GRegex structures.
1090  *
1091  * A #GMatchInfo structure, used to get information on the match,
1092  * is stored in @match_info if not %NULL. Note that if @match_info
1093  * is not %NULL then it is created even if the function returns %FALSE,
1094  * i.e. you must free it regardless if regular expression actually matched.
1095  *
1096  * To retrieve all the non-overlapping matches of the pattern in
1097  * string you can use g_match_info_next().
1098  *
1099  * <informalexample><programlisting>
1100  * static void
1101  * print_uppercase_words (const gchar *string)
1102  * {
1103  *   /&ast; Print all uppercase-only words. &ast;/
1104  *   GRegex *regex;
1105  *   GMatchInfo *match_info;
1106  *   &nbsp;
1107  *   regex = g_regex_new ("[A-Z]+", 0, 0, NULL);
1108  *   g_regex_match (regex, string, 0, &amp;match_info);
1109  *   while (g_match_info_matches (match_info))
1110  *     {
1111  *       gchar *word = g_match_info_fetch (match_info, 0);
1112  *       g_print ("Found: %s\n", word);
1113  *       g_free (word);
1114  *       g_match_info_next (match_info, NULL);
1115  *     }
1116  *   g_match_info_free (match_info);
1117  *   g_regex_unref (regex);
1118  * }
1119  * </programlisting></informalexample>
1120  *
1121  * Returns: %TRUE is the string matched, %FALSE otherwise
1122  *
1123  * Since: 2.14
1124  */
1125 gboolean
1126 g_regex_match (const GRegex      *regex,
1127                const gchar       *string,
1128                GRegexMatchFlags   match_options,
1129                GMatchInfo       **match_info)
1130 {
1131   return g_regex_match_full (regex, string, -1, 0, match_options,
1132                              match_info, NULL);
1133 }
1134
1135 /**
1136  * g_regex_match_full:
1137  * @regex: a #GRegex structure from g_regex_new()
1138  * @string: the string to scan for matches
1139  * @string_len: the length of @string, or -1 if @string is nul-terminated
1140  * @start_position: starting index of the string to match
1141  * @match_options: match options
1142  * @match_info: pointer to location where to store the #GMatchInfo,
1143  *   or %NULL if you do not need it
1144  * @error: location to store the error occuring, or %NULL to ignore errors
1145  *
1146  * Scans for a match in string for the pattern in @regex.
1147  * The @match_options are combined with the match options specified
1148  * when the @regex structure was created, letting you have more
1149  * flexibility in reusing #GRegex structures.
1150  *
1151  * Setting @start_position differs from just passing over a shortened
1152  * string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern
1153  * that begins with any kind of lookbehind assertion, such as "\b".
1154  *
1155  * A #GMatchInfo structure, used to get information on the match, is
1156  * stored in @match_info if not %NULL. Note that if @match_info is
1157  * not %NULL then it is created even if the function returns %FALSE,
1158  * i.e. you must free it regardless if regular expression actually
1159  * matched.
1160  *
1161  * @string is not copied and is used in #GMatchInfo internally. If
1162  * you use any #GMatchInfo method (except g_match_info_free()) after
1163  * freeing or modifying @string then the behaviour is undefined.
1164  *
1165  * To retrieve all the non-overlapping matches of the pattern in
1166  * string you can use g_match_info_next().
1167  *
1168  * <informalexample><programlisting>
1169  * static void
1170  * print_uppercase_words (const gchar *string)
1171  * {
1172  *   /&ast; Print all uppercase-only words. &ast;/
1173  *   GRegex *regex;
1174  *   GMatchInfo *match_info;
1175  *   GError *error = NULL;
1176  *   &nbsp;
1177  *   regex = g_regex_new ("[A-Z]+", 0, 0, NULL);
1178  *   g_regex_match_full (regex, string, -1, 0, 0, &amp;match_info, &amp;error);
1179  *   while (g_match_info_matches (match_info))
1180  *     {
1181  *       gchar *word = g_match_info_fetch (match_info, 0);
1182  *       g_print ("Found: %s\n", word);
1183  *       g_free (word);
1184  *       g_match_info_next (match_info, &amp;error);
1185  *     }
1186  *   g_match_info_free (match_info);
1187  *   g_regex_unref (regex);
1188  *   if (error != NULL)
1189  *     {
1190  *       g_printerr ("Error while matching: %s\n", error->message);
1191  *       g_error_free (error);
1192  *     }
1193  * }
1194  * </programlisting></informalexample>
1195  *
1196  * Returns: %TRUE is the string matched, %FALSE otherwise
1197  *
1198  * Since: 2.14
1199  */
1200 gboolean
1201 g_regex_match_full (const GRegex      *regex,
1202                     const gchar       *string,
1203                     gssize             string_len,
1204                     gint               start_position,
1205                     GRegexMatchFlags   match_options,
1206                     GMatchInfo       **match_info,
1207                     GError           **error)
1208 {
1209   GMatchInfo *info;
1210   gboolean match_ok;
1211
1212   g_return_val_if_fail (regex != NULL, FALSE);
1213   g_return_val_if_fail (string != NULL, FALSE);
1214   g_return_val_if_fail (start_position >= 0, FALSE);
1215   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
1216   g_return_val_if_fail ((match_options & ~G_REGEX_MATCH_MASK) == 0, FALSE);
1217
1218   info = match_info_new (regex, string, string_len, start_position,
1219                          match_options, FALSE);
1220   match_ok = g_match_info_next (info, error);
1221   if (match_info != NULL)
1222     *match_info = info;
1223   else
1224     g_match_info_free (info);
1225
1226   return match_ok;
1227 }
1228
1229 /**
1230  * g_regex_match_all:
1231  * @regex: a #GRegex structure from g_regex_new()
1232  * @string: the string to scan for matches
1233  * @match_options: match options
1234  * @match_info: pointer to location where to store the #GMatchInfo,
1235  *   or %NULL if you do not need it
1236  *
1237  * Using the standard algorithm for regular expression matching only
1238  * the longest match in the string is retrieved. This function uses
1239  * a different algorithm so it can retrieve all the possible matches.
1240  * For more documentation see g_regex_match_all_full().
1241  *
1242  * A #GMatchInfo structure, used to get information on the match, is
1243  * stored in @match_info if not %NULL. Note that if @match_info is
1244  * not %NULL then it is created even if the function returns %FALSE,
1245  * i.e. you must free it regardless if regular expression actually
1246  * matched.
1247  *
1248  * Returns: %TRUE is the string matched, %FALSE otherwise
1249  *
1250  * Since: 2.14
1251  */
1252 gboolean
1253 g_regex_match_all (const GRegex      *regex,
1254                    const gchar       *string,
1255                    GRegexMatchFlags   match_options,
1256                    GMatchInfo       **match_info)
1257 {
1258   return g_regex_match_all_full (regex, string, -1, 0, match_options,
1259                                  match_info, NULL);
1260 }
1261
1262 /**
1263  * g_regex_match_all_full:
1264  * @regex: a #GRegex structure from g_regex_new()
1265  * @string: the string to scan for matches
1266  * @string_len: the length of @string, or -1 if @string is nul-terminated
1267  * @start_position: starting index of the string to match
1268  * @match_options: match options
1269  * @match_info: pointer to location where to store the #GMatchInfo,
1270  *   or %NULL if you do not need it
1271  * @error: location to store the error occuring, or %NULL to ignore errors
1272  *
1273  * Using the standard algorithm for regular expression matching only
1274  * the longest match in the string is retrieved, it is not possibile
1275  * to obtain all the available matches. For instance matching
1276  * "&lt;a&gt; &lt;b&gt; &lt;c&gt;" against the pattern "&lt;.*&gt;"
1277  * you get "&lt;a&gt; &lt;b&gt; &lt;c&gt;".
1278  *
1279  * This function uses a different algorithm (called DFA, i.e. deterministic
1280  * finite automaton), so it can retrieve all the possible matches, all
1281  * starting at the same point in the string. For instance matching
1282  * "&lt;a&gt; &lt;b&gt; &lt;c&gt;" against the pattern "&lt;.*&gt;"
1283  * you would obtain three matches: "&lt;a&gt; &lt;b&gt; &lt;c&gt;",
1284  * "&lt;a&gt; &lt;b&gt;" and "&lt;a&gt;".
1285  *
1286  * The number of matched strings is retrieved using
1287  * g_match_info_get_match_count(). To obtain the matched strings and
1288  * their position you can use, respectively, g_match_info_fetch() and
1289  * g_match_info_fetch_pos(). Note that the strings are returned in
1290  * reverse order of length; that is, the longest matching string is
1291  * given first.
1292  *
1293  * Note that the DFA algorithm is slower than the standard one and it
1294  * is not able to capture substrings, so backreferences do not work.
1295  *
1296  * Setting @start_position differs from just passing over a shortened
1297  * string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern
1298  * that begins with any kind of lookbehind assertion, such as "\b".
1299  *
1300  * A #GMatchInfo structure, used to get information on the match, is
1301  * stored in @match_info if not %NULL. Note that if @match_info is
1302  * not %NULL then it is created even if the function returns %FALSE,
1303  * i.e. you must free it regardless if regular expression actually
1304  * matched.
1305  *
1306  * Returns: %TRUE is the string matched, %FALSE otherwise
1307  *
1308  * Since: 2.14
1309  */
1310 gboolean
1311 g_regex_match_all_full (const GRegex      *regex,
1312                         const gchar       *string,
1313                         gssize             string_len,
1314                         gint               start_position,
1315                         GRegexMatchFlags   match_options,
1316                         GMatchInfo       **match_info,
1317                         GError           **error)
1318 {
1319   GMatchInfo *info;
1320   gboolean done;
1321
1322   g_return_val_if_fail (regex != NULL, FALSE);
1323   g_return_val_if_fail (string != NULL, FALSE);
1324   g_return_val_if_fail (start_position >= 0, FALSE);
1325   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
1326   g_return_val_if_fail ((match_options & ~G_REGEX_MATCH_MASK) == 0, FALSE);
1327
1328   info = match_info_new (regex, string, string_len, start_position,
1329                          match_options, TRUE);
1330
1331   done = FALSE;
1332   while (!done)
1333     {
1334       done = TRUE;
1335       info->matches = pcre_dfa_exec (regex->pcre_re, regex->extra,
1336                                      info->string, info->string_len,
1337                                      info->pos,
1338                                      regex->match_opts | match_options,
1339                                      info->offsets, info->n_offsets,
1340                                      info->workspace, info->n_workspace);
1341       if (info->matches == PCRE_ERROR_DFA_WSSIZE)
1342         {
1343           /* info->workspace is too small. */
1344           info->n_workspace *= 2;
1345           info->workspace = g_realloc (info->workspace,
1346                                        info->n_workspace * sizeof (gint));
1347           done = FALSE;
1348         }
1349       else if (info->matches == 0)
1350         {
1351           /* info->offsets is too small. */
1352           info->n_offsets *= 2;
1353           info->offsets = g_realloc (info->offsets,
1354                                      info->n_offsets * sizeof (gint));
1355           done = FALSE;
1356         }
1357       else if (IS_PCRE_ERROR (info->matches))
1358         {
1359           g_set_error (error, G_REGEX_ERROR, G_REGEX_ERROR_MATCH,
1360                        _("Error while matching regular expression %s: %s"),
1361                        regex->pattern, match_error (info->matches));
1362         }
1363     }
1364
1365   /* set info->pos to -1 so that a call to g_match_info_next() fails. */
1366   info->pos = -1;
1367
1368   if (match_info != NULL)
1369     *match_info = info;
1370   else
1371     g_match_info_free (info);
1372
1373   return info->matches >= 0;
1374 }
1375
1376 /**
1377  * g_regex_get_string_number:
1378  * @regex: #GRegex structure
1379  * @name: name of the subexpression
1380  *
1381  * Retrieves the number of the subexpression named @name.
1382  *
1383  * Returns: The number of the subexpression or -1 if @name
1384  *   does not exists
1385  *
1386  * Since: 2.14
1387  */
1388 gint
1389 g_regex_get_string_number (const GRegex *regex,
1390                            const gchar  *name)
1391 {
1392   gint num;
1393
1394   g_return_val_if_fail (regex != NULL, -1);
1395   g_return_val_if_fail (name != NULL, -1);
1396
1397   num = pcre_get_stringnumber (regex->pcre_re, name);
1398   if (num == PCRE_ERROR_NOSUBSTRING)
1399     num = -1;
1400
1401   return num;
1402 }
1403
1404 /**
1405  * g_regex_split_simple:
1406  * @pattern: the regular expression
1407  * @string: the string to scan for matches
1408  * @compile_options: compile options for the regular expression
1409  * @match_options: match options
1410  *
1411  * Breaks the string on the pattern, and returns an array of
1412  * the tokens. If the pattern contains capturing parentheses,
1413  * then the text for each of the substrings will also be returned.
1414  * If the pattern does not match anywhere in the string, then the
1415  * whole string is returned as the first token.
1416  *
1417  * This function is equivalent to g_regex_split() but it does
1418  * not require to compile the pattern with g_regex_new(), avoiding
1419  * some lines of code when you need just to do a split without
1420  * extracting substrings, capture counts, and so on.
1421  *
1422  * If this function is to be called on the same @pattern more than
1423  * once, it's more efficient to compile the pattern once with
1424  * g_regex_new() and then use g_regex_split().
1425  *
1426  * As a special case, the result of splitting the empty string ""
1427  * is an empty vector, not a vector containing a single string.
1428  * The reason for this special case is that being able to represent
1429  * a empty vector is typically more useful than consistent handling
1430  * of empty elements. If you do need to represent empty elements,
1431  * you'll need to check for the empty string before calling this
1432  * function.
1433  *
1434  * A pattern that can match empty strings splits @string into
1435  * separate characters wherever it matches the empty string between
1436  * characters. For example splitting "ab c" using as a separator
1437  * "\s*", you will get "a", "b" and "c".
1438  *
1439  * Returns: a %NULL-terminated gchar ** array. Free it using g_strfreev()
1440  *
1441  * Since: 2.14
1442  **/
1443 gchar **
1444 g_regex_split_simple (const gchar        *pattern,
1445                       const gchar        *string,
1446                       GRegexCompileFlags  compile_options,
1447                       GRegexMatchFlags    match_options)
1448 {
1449   GRegex *regex;
1450   gchar **result;
1451
1452   regex = g_regex_new (pattern, compile_options, 0, NULL);
1453   if (!regex)
1454     return NULL;
1455   result = g_regex_split_full (regex, string, -1, 0, match_options, 0, NULL);
1456   g_regex_unref (regex);
1457   return result;
1458 }
1459
1460 /**
1461  * g_regex_split:
1462  * @regex: a #GRegex structure
1463  * @string: the string to split with the pattern
1464  * @match_options: match time option flags
1465  *
1466  * Breaks the string on the pattern, and returns an array of the tokens.
1467  * If the pattern contains capturing parentheses, then the text for each
1468  * of the substrings will also be returned. If the pattern does not match
1469  * anywhere in the string, then the whole string is returned as the first
1470  * token.
1471  *
1472  * As a special case, the result of splitting the empty string "" is an
1473  * empty vector, not a vector containing a single string. The reason for
1474  * this special case is that being able to represent a empty vector is
1475  * typically more useful than consistent handling of empty elements. If
1476  * you do need to represent empty elements, you'll need to check for the
1477  * empty string before calling this function.
1478  *
1479  * A pattern that can match empty strings splits @string into separate
1480  * characters wherever it matches the empty string between characters.
1481  * For example splitting "ab c" using as a separator "\s*", you will get
1482  * "a", "b" and "c".
1483  *
1484  * Returns: a %NULL-terminated gchar ** array. Free it using g_strfreev()
1485  *
1486  * Since: 2.14
1487  **/
1488 gchar **
1489 g_regex_split (const GRegex     *regex,
1490                const gchar      *string,
1491                GRegexMatchFlags  match_options)
1492 {
1493   return g_regex_split_full (regex, string, -1, 0,
1494                              match_options, 0, NULL);
1495 }
1496
1497 /**
1498  * g_regex_split_full:
1499  * @regex: a #GRegex structure
1500  * @string: the string to split with the pattern
1501  * @string_len: the length of @string, or -1 if @string is nul-terminated
1502  * @start_position: starting index of the string to match
1503  * @match_options: match time option flags
1504  * @max_tokens: the maximum number of tokens to split @string into.
1505  *   If this is less than 1, the string is split completely
1506  * @error: return location for a #GError
1507  *
1508  * Breaks the string on the pattern, and returns an array of the tokens.
1509  * If the pattern contains capturing parentheses, then the text for each
1510  * of the substrings will also be returned. If the pattern does not match
1511  * anywhere in the string, then the whole string is returned as the first
1512  * token.
1513  *
1514  * As a special case, the result of splitting the empty string "" is an
1515  * empty vector, not a vector containing a single string. The reason for
1516  * this special case is that being able to represent a empty vector is
1517  * typically more useful than consistent handling of empty elements. If
1518  * you do need to represent empty elements, you'll need to check for the
1519  * empty string before calling this function.
1520  *
1521  * A pattern that can match empty strings splits @string into separate
1522  * characters wherever it matches the empty string between characters.
1523  * For example splitting "ab c" using as a separator "\s*", you will get
1524  * "a", "b" and "c".
1525  *
1526  * Setting @start_position differs from just passing over a shortened
1527  * string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern
1528  * that begins with any kind of lookbehind assertion, such as "\b".
1529  *
1530  * Returns: a %NULL-terminated gchar ** array. Free it using g_strfreev()
1531  *
1532  * Since: 2.14
1533  **/
1534 gchar **
1535 g_regex_split_full (const GRegex      *regex,
1536                     const gchar       *string,
1537                     gssize             string_len,
1538                     gint               start_position,
1539                     GRegexMatchFlags   match_options,
1540                     gint               max_tokens,
1541                     GError           **error)
1542 {
1543   GError *tmp_error = NULL;
1544   GMatchInfo *match_info;
1545   GList *list, *last;
1546   gint i;
1547   gint token_count;
1548   gboolean match_ok;
1549   /* position of the last separator. */
1550   gint last_separator_end;
1551   /* was the last match 0 bytes long? */
1552   gboolean last_match_is_empty;
1553   /* the returned array of char **s */
1554   gchar **string_list;
1555
1556   g_return_val_if_fail (regex != NULL, NULL);
1557   g_return_val_if_fail (string != NULL, NULL);
1558   g_return_val_if_fail (start_position >= 0, NULL);
1559   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
1560   g_return_val_if_fail ((match_options & ~G_REGEX_MATCH_MASK) == 0, NULL);
1561
1562   if (max_tokens <= 0)
1563     max_tokens = G_MAXINT;
1564
1565   if (string_len < 0)
1566     string_len = strlen (string);
1567
1568   /* zero-length string */
1569   if (string_len - start_position == 0)
1570     return g_new0 (gchar *, 1);
1571
1572   if (max_tokens == 1)
1573     {
1574       string_list = g_new0 (gchar *, 2);
1575       string_list[0] = g_strndup (&string[start_position],
1576                                   string_len - start_position);
1577       return string_list;
1578     }
1579
1580   list = NULL;
1581   token_count = 0;
1582   last_separator_end = start_position;
1583   last_match_is_empty = FALSE;
1584
1585   match_ok = g_regex_match_full (regex, string, string_len, start_position,
1586                                  match_options, &match_info, &tmp_error);
1587   while (tmp_error == NULL)
1588     {
1589       if (match_ok)
1590         {
1591           last_match_is_empty =
1592                     (match_info->offsets[0] == match_info->offsets[1]);
1593
1594           /* we need to skip empty separators at the same position of the end
1595            * of another separator. e.g. the string is "a b" and the separator
1596            * is " *", so from 1 to 2 we have a match and at position 2 we have
1597            * an empty match. */
1598           if (last_separator_end != match_info->offsets[1])
1599             {
1600               gchar *token;
1601               gint match_count;
1602
1603               token = g_strndup (string + last_separator_end,
1604                                  match_info->offsets[0] - last_separator_end);
1605               list = g_list_prepend (list, token);
1606               token_count++;
1607
1608               /* if there were substrings, these need to be added to
1609                * the list. */
1610               match_count = g_match_info_get_match_count (match_info);
1611               if (match_count > 1)
1612                 {
1613                   for (i = 1; i < match_count; i++)
1614                     list = g_list_prepend (list, g_match_info_fetch (match_info, i));
1615                 }
1616             }
1617         }
1618       else
1619         {
1620           /* if there was no match, copy to end of string. */
1621           if (!last_match_is_empty)
1622             {
1623               gchar *token = g_strndup (string + last_separator_end,
1624                                         match_info->string_len - last_separator_end);
1625               list = g_list_prepend (list, token);
1626             }
1627           /* no more tokens, end the loop. */
1628           break;
1629         }
1630
1631       /* -1 to leave room for the last part. */
1632       if (token_count >= max_tokens - 1)
1633         {
1634           /* we have reached the maximum number of tokens, so we copy
1635            * the remaining part of the string. */
1636           if (last_match_is_empty)
1637             {
1638               /* the last match was empty, so we have moved one char
1639                * after the real position to avoid empty matches at the
1640                * same position. */
1641               match_info->pos = PREV_CHAR (regex, &string[match_info->pos]) - string;
1642             }
1643           /* the if is needed in the case we have terminated the available
1644            * tokens, but we are at the end of the string, so there are no
1645            * characters left to copy. */
1646           if (string_len > match_info->pos)
1647             {
1648               gchar *token = g_strndup (string + match_info->pos,
1649                                         string_len - match_info->pos);
1650               list = g_list_prepend (list, token);
1651             }
1652           /* end the loop. */
1653           break;
1654         }
1655
1656       last_separator_end = match_info->pos;
1657       if (last_match_is_empty)
1658         /* if the last match was empty, g_match_info_next() has moved
1659          * forward to avoid infinite loops, but we still need to copy that
1660          * character. */
1661         last_separator_end = PREV_CHAR (regex, &string[last_separator_end]) - string;
1662
1663       match_ok = g_match_info_next (match_info, &tmp_error);
1664     }
1665   g_match_info_free (match_info);
1666   if (tmp_error != NULL)
1667     {
1668       g_propagate_error (error, tmp_error);
1669       g_list_foreach (list, (GFunc)g_free, NULL);
1670       g_list_free (list);
1671       match_info->pos = -1;
1672       return NULL;
1673     }
1674
1675   string_list = g_new (gchar *, g_list_length (list) + 1);
1676   i = 0;
1677   for (last = g_list_last (list); last; last = g_list_previous (last))
1678     string_list[i++] = last->data;
1679   string_list[i] = 0;
1680   g_list_free (list);
1681
1682   return string_list;
1683 }
1684
1685 enum
1686 {
1687   REPL_TYPE_STRING,
1688   REPL_TYPE_CHARACTER,
1689   REPL_TYPE_SYMBOLIC_REFERENCE,
1690   REPL_TYPE_NUMERIC_REFERENCE,
1691   REPL_TYPE_CHANGE_CASE
1692 };
1693
1694 typedef enum
1695 {
1696   CHANGE_CASE_NONE         = 1 << 0,
1697   CHANGE_CASE_UPPER        = 1 << 1,
1698   CHANGE_CASE_LOWER        = 1 << 2,
1699   CHANGE_CASE_UPPER_SINGLE = 1 << 3,
1700   CHANGE_CASE_LOWER_SINGLE = 1 << 4,
1701   CHANGE_CASE_SINGLE_MASK  = CHANGE_CASE_UPPER_SINGLE | CHANGE_CASE_LOWER_SINGLE,
1702   CHANGE_CASE_LOWER_MASK   = CHANGE_CASE_LOWER | CHANGE_CASE_LOWER_SINGLE,
1703   CHANGE_CASE_UPPER_MASK   = CHANGE_CASE_UPPER | CHANGE_CASE_UPPER_SINGLE
1704 } ChangeCase;
1705
1706 struct _InterpolationData
1707 {
1708   gchar     *text;
1709   gint       type;
1710   gint       num;
1711   gchar      c;
1712   ChangeCase change_case;
1713 };
1714
1715 static void
1716 free_interpolation_data (InterpolationData *data)
1717 {
1718   g_free (data->text);
1719   g_free (data);
1720 }
1721
1722 static const gchar *
1723 expand_escape (const gchar        *replacement,
1724                const gchar        *p,
1725                InterpolationData  *data,
1726                GError            **error)
1727 {
1728   const gchar *q, *r;
1729   gint x, d, h, i;
1730   const gchar *error_detail;
1731   gint base = 0;
1732   GError *tmp_error = NULL;
1733
1734   p++;
1735   switch (*p)
1736     {
1737     case 't':
1738       p++;
1739       data->c = '\t';
1740       data->type = REPL_TYPE_CHARACTER;
1741       break;
1742     case 'n':
1743       p++;
1744       data->c = '\n';
1745       data->type = REPL_TYPE_CHARACTER;
1746       break;
1747     case 'v':
1748       p++;
1749       data->c = '\v';
1750       data->type = REPL_TYPE_CHARACTER;
1751       break;
1752     case 'r':
1753       p++;
1754       data->c = '\r';
1755       data->type = REPL_TYPE_CHARACTER;
1756       break;
1757     case 'f':
1758       p++;
1759       data->c = '\f';
1760       data->type = REPL_TYPE_CHARACTER;
1761       break;
1762     case 'a':
1763       p++;
1764       data->c = '\a';
1765       data->type = REPL_TYPE_CHARACTER;
1766       break;
1767     case 'b':
1768       p++;
1769       data->c = '\b';
1770       data->type = REPL_TYPE_CHARACTER;
1771       break;
1772     case '\\':
1773       p++;
1774       data->c = '\\';
1775       data->type = REPL_TYPE_CHARACTER;
1776       break;
1777     case 'x':
1778       p++;
1779       x = 0;
1780       if (*p == '{')
1781         {
1782           p++;
1783           do
1784             {
1785               h = g_ascii_xdigit_value (*p);
1786               if (h < 0)
1787                 {
1788                   error_detail = _("hexadecimal digit or '}' expected");
1789                   goto error;
1790                 }
1791               x = x * 16 + h;
1792               p++;
1793             }
1794           while (*p != '}');
1795           p++;
1796         }
1797       else
1798         {
1799           for (i = 0; i < 2; i++)
1800             {
1801               h = g_ascii_xdigit_value (*p);
1802               if (h < 0)
1803                 {
1804                   error_detail = _("hexadecimal digit expected");
1805                   goto error;
1806                 }
1807               x = x * 16 + h;
1808               p++;
1809             }
1810         }
1811       data->type = REPL_TYPE_STRING;
1812       data->text = g_new0 (gchar, 8);
1813       g_unichar_to_utf8 (x, data->text);
1814       break;
1815     case 'l':
1816       p++;
1817       data->type = REPL_TYPE_CHANGE_CASE;
1818       data->change_case = CHANGE_CASE_LOWER_SINGLE;
1819       break;
1820     case 'u':
1821       p++;
1822       data->type = REPL_TYPE_CHANGE_CASE;
1823       data->change_case = CHANGE_CASE_UPPER_SINGLE;
1824       break;
1825     case 'L':
1826       p++;
1827       data->type = REPL_TYPE_CHANGE_CASE;
1828       data->change_case = CHANGE_CASE_LOWER;
1829       break;
1830     case 'U':
1831       p++;
1832       data->type = REPL_TYPE_CHANGE_CASE;
1833       data->change_case = CHANGE_CASE_UPPER;
1834       break;
1835     case 'E':
1836       p++;
1837       data->type = REPL_TYPE_CHANGE_CASE;
1838       data->change_case = CHANGE_CASE_NONE;
1839       break;
1840     case 'g':
1841       p++;
1842       if (*p != '<')
1843         {
1844           error_detail = _("missing '<' in symbolic reference");
1845           goto error;
1846         }
1847       q = p + 1;
1848       do
1849         {
1850           p++;
1851           if (!*p)
1852             {
1853               error_detail = _("unfinished symbolic reference");
1854               goto error;
1855             }
1856         }
1857       while (*p != '>');
1858       if (p - q == 0)
1859         {
1860           error_detail = _("zero-length symbolic reference");
1861           goto error;
1862         }
1863       if (g_ascii_isdigit (*q))
1864         {
1865           x = 0;
1866           do
1867             {
1868               h = g_ascii_digit_value (*q);
1869               if (h < 0)
1870                 {
1871                   error_detail = _("digit expected");
1872                   p = q;
1873                   goto error;
1874                 }
1875               x = x * 10 + h;
1876               q++;
1877             }
1878           while (q != p);
1879           data->num = x;
1880           data->type = REPL_TYPE_NUMERIC_REFERENCE;
1881         }
1882       else
1883         {
1884           r = q;
1885           do
1886             {
1887               if (!g_ascii_isalnum (*r))
1888                 {
1889                   error_detail = _("illegal symbolic reference");
1890                   p = r;
1891                   goto error;
1892                 }
1893               r++;
1894             }
1895           while (r != p);
1896           data->text = g_strndup (q, p - q);
1897           data->type = REPL_TYPE_SYMBOLIC_REFERENCE;
1898         }
1899       p++;
1900       break;
1901     case '0':
1902       /* if \0 is followed by a number is an octal number representing a
1903        * character, else it is a numeric reference. */
1904       if (g_ascii_digit_value (*g_utf8_next_char (p)) >= 0)
1905         {
1906           base = 8;
1907           p = g_utf8_next_char (p);
1908         }
1909     case '1':
1910     case '2':
1911     case '3':
1912     case '4':
1913     case '5':
1914     case '6':
1915     case '7':
1916     case '8':
1917     case '9':
1918       x = 0;
1919       d = 0;
1920       for (i = 0; i < 3; i++)
1921         {
1922           h = g_ascii_digit_value (*p);
1923           if (h < 0)
1924             break;
1925           if (h > 7)
1926             {
1927               if (base == 8)
1928                 break;
1929               else
1930                 base = 10;
1931             }
1932           if (i == 2 && base == 10)
1933             break;
1934           x = x * 8 + h;
1935           d = d * 10 + h;
1936           p++;
1937         }
1938       if (base == 8 || i == 3)
1939         {
1940           data->type = REPL_TYPE_STRING;
1941           data->text = g_new0 (gchar, 8);
1942           g_unichar_to_utf8 (x, data->text);
1943         }
1944       else
1945         {
1946           data->type = REPL_TYPE_NUMERIC_REFERENCE;
1947           data->num = d;
1948         }
1949       break;
1950     case 0:
1951       error_detail = _("stray final '\\'");
1952       goto error;
1953       break;
1954     default:
1955       error_detail = _("unknown escape sequence");
1956       goto error;
1957     }
1958
1959   return p;
1960
1961  error:
1962   /* G_GSSIZE_FORMAT doesn't work with gettext, so we use %lu */
1963   tmp_error = g_error_new (G_REGEX_ERROR,
1964                            G_REGEX_ERROR_REPLACE,
1965                            _("Error while parsing replacement "
1966                              "text \"%s\" at char %lu: %s"),
1967                            replacement,
1968                            (gulong)(p - replacement),
1969                            error_detail);
1970   g_propagate_error (error, tmp_error);
1971
1972   return NULL;
1973 }
1974
1975 static GList *
1976 split_replacement (const gchar  *replacement,
1977                    GError      **error)
1978 {
1979   GList *list = NULL;
1980   InterpolationData *data;
1981   const gchar *p, *start;
1982
1983   start = p = replacement;
1984   while (*p)
1985     {
1986       if (*p == '\\')
1987         {
1988           data = g_new0 (InterpolationData, 1);
1989           start = p = expand_escape (replacement, p, data, error);
1990           if (p == NULL)
1991             {
1992               g_list_foreach (list, (GFunc)free_interpolation_data, NULL);
1993               g_list_free (list);
1994               free_interpolation_data (data);
1995
1996               return NULL;
1997             }
1998           list = g_list_prepend (list, data);
1999         }
2000       else
2001         {
2002           p++;
2003           if (*p == '\\' || *p == '\0')
2004             {
2005               if (p - start > 0)
2006                 {
2007                   data = g_new0 (InterpolationData, 1);
2008                   data->text = g_strndup (start, p - start);
2009                   data->type = REPL_TYPE_STRING;
2010                   list = g_list_prepend (list, data);
2011                 }
2012             }
2013         }
2014     }
2015
2016   return g_list_reverse (list);
2017 }
2018
2019 /* Change the case of c based on change_case. */
2020 #define CHANGE_CASE(c, change_case) \
2021         (((change_case) & CHANGE_CASE_LOWER_MASK) ? \
2022                 g_unichar_tolower (c) : \
2023                 g_unichar_toupper (c))
2024
2025 static void
2026 string_append (GString     *string,
2027                const gchar *text,
2028                ChangeCase  *change_case)
2029 {
2030   gunichar c;
2031
2032   if (text[0] == '\0')
2033     return;
2034
2035   if (*change_case == CHANGE_CASE_NONE)
2036     {
2037       g_string_append (string, text);
2038     }
2039   else if (*change_case & CHANGE_CASE_SINGLE_MASK)
2040     {
2041       c = g_utf8_get_char (text);
2042       g_string_append_unichar (string, CHANGE_CASE (c, *change_case));
2043       g_string_append (string, g_utf8_next_char (text));
2044       *change_case = CHANGE_CASE_NONE;
2045     }
2046   else
2047     {
2048       while (*text != '\0')
2049         {
2050           c = g_utf8_get_char (text);
2051           g_string_append_unichar (string, CHANGE_CASE (c, *change_case));
2052           text = g_utf8_next_char (text);
2053         }
2054     }
2055 }
2056
2057 static gboolean
2058 interpolate_replacement (const GMatchInfo *match_info,
2059                          GString          *result,
2060                          gpointer          data)
2061 {
2062   GList *list;
2063   InterpolationData *idata;
2064   gchar *match;
2065   ChangeCase change_case = CHANGE_CASE_NONE;
2066
2067   for (list = data; list; list = list->next)
2068     {
2069       idata = list->data;
2070       switch (idata->type)
2071         {
2072         case REPL_TYPE_STRING:
2073           string_append (result, idata->text, &change_case);
2074           break;
2075         case REPL_TYPE_CHARACTER:
2076           g_string_append_c (result, CHANGE_CASE (idata->c, change_case));
2077           if (change_case & CHANGE_CASE_SINGLE_MASK)
2078             change_case = CHANGE_CASE_NONE;
2079           break;
2080         case REPL_TYPE_NUMERIC_REFERENCE:
2081           match = g_match_info_fetch (match_info, idata->num);
2082           if (match)
2083             {
2084               string_append (result, match, &change_case);
2085               g_free (match);
2086             }
2087           break;
2088         case REPL_TYPE_SYMBOLIC_REFERENCE:
2089           match = g_match_info_fetch_named (match_info, idata->text);
2090           if (match)
2091             {
2092               string_append (result, match, &change_case);
2093               g_free (match);
2094             }
2095           break;
2096         case REPL_TYPE_CHANGE_CASE:
2097           change_case = idata->change_case;
2098           break;
2099         }
2100     }
2101
2102   return FALSE;
2103 }
2104
2105 /* whether actual match_info is needed for replacement, i.e.
2106  * whether there are references
2107  */
2108 static gboolean
2109 interpolation_list_needs_match (GList *list)
2110 {
2111   while (list != NULL)
2112     {
2113       InterpolationData *data = list->data;
2114
2115       if (data->type == REPL_TYPE_SYMBOLIC_REFERENCE ||
2116           data->type == REPL_TYPE_NUMERIC_REFERENCE)
2117         {
2118           return TRUE;
2119         }
2120
2121       list = list->next;
2122     }
2123
2124   return FALSE;
2125 }
2126
2127 /**
2128  * g_regex_replace:
2129  * @regex: a #GRegex structure
2130  * @string: the string to perform matches against
2131  * @string_len: the length of @string, or -1 if @string is nul-terminated
2132  * @start_position: starting index of the string to match
2133  * @replacement: text to replace each match with
2134  * @match_options: options for the match
2135  * @error: location to store the error occuring, or %NULL to ignore errors
2136  *
2137  * Replaces all occurances of the pattern in @regex with the
2138  * replacement text. Backreferences of the form '\number' or
2139  * '\g&lt;number&gt;' in the replacement text are interpolated by the
2140  * number-th captured subexpression of the match, '\g&lt;name&gt;' refers
2141  * to the captured subexpression with the given name. '\0' refers to the
2142  * complete match, but '\0' followed by a number is the octal representation
2143  * of a character. To include a literal '\' in the replacement, write '\\'.
2144  * There are also escapes that changes the case of the following text:
2145  *
2146  * <variablelist>
2147  * <varlistentry><term>\l</term>
2148  * <listitem>
2149  * <para>Convert to lower case the next character</para>
2150  * </listitem>
2151  * </varlistentry>
2152  * <varlistentry><term>\u</term>
2153  * <listitem>
2154  * <para>Convert to upper case the next character</para>
2155  * </listitem>
2156  * </varlistentry>
2157  * <varlistentry><term>\L</term>
2158  * <listitem>
2159  * <para>Convert to lower case till \E</para>
2160  * </listitem>
2161  * </varlistentry>
2162  * <varlistentry><term>\U</term>
2163  * <listitem>
2164  * <para>Convert to upper case till \E</para>
2165  * </listitem>
2166  * </varlistentry>
2167  * <varlistentry><term>\E</term>
2168  * <listitem>
2169  * <para>End case modification</para>
2170  * </listitem>
2171  * </varlistentry>
2172  * </variablelist>
2173  *
2174  * If you do not need to use backreferences use g_regex_replace_literal().
2175  *
2176  * The @replacement string must be UTF-8 encoded even if #G_REGEX_RAW was
2177  * passed to g_regex_new(). If you want to use not UTF-8 encoded stings
2178  * you can use g_regex_replace_literal().
2179  *
2180  * Setting @start_position differs from just passing over a shortened
2181  * string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern that
2182  * begins with any kind of lookbehind assertion, such as "\b".
2183  *
2184  * Returns: a newly allocated string containing the replacements
2185  *
2186  * Since: 2.14
2187  */
2188 gchar *
2189 g_regex_replace (const GRegex      *regex,
2190                  const gchar       *string,
2191                  gssize             string_len,
2192                  gint               start_position,
2193                  const gchar       *replacement,
2194                  GRegexMatchFlags   match_options,
2195                  GError           **error)
2196 {
2197   gchar *result;
2198   GList *list;
2199   GError *tmp_error = NULL;
2200
2201   g_return_val_if_fail (regex != NULL, NULL);
2202   g_return_val_if_fail (string != NULL, NULL);
2203   g_return_val_if_fail (start_position >= 0, NULL);
2204   g_return_val_if_fail (replacement != NULL, NULL);
2205   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
2206   g_return_val_if_fail ((match_options & ~G_REGEX_MATCH_MASK) == 0, NULL);
2207
2208   list = split_replacement (replacement, &tmp_error);
2209   if (tmp_error != NULL)
2210     {
2211       g_propagate_error (error, tmp_error);
2212       return NULL;
2213     }
2214
2215   result = g_regex_replace_eval (regex,
2216                                  string, string_len, start_position,
2217                                  match_options,
2218                                  interpolate_replacement,
2219                                  (gpointer)list,
2220                                  &tmp_error);
2221   if (tmp_error != NULL)
2222     g_propagate_error (error, tmp_error);
2223
2224   g_list_foreach (list, (GFunc)free_interpolation_data, NULL);
2225   g_list_free (list);
2226
2227   return result;
2228 }
2229
2230 static gboolean
2231 literal_replacement (const GMatchInfo *match_info,
2232                      GString          *result,
2233                      gpointer          data)
2234 {
2235   g_string_append (result, data);
2236   return FALSE;
2237 }
2238
2239 /**
2240  * g_regex_replace_literal:
2241  * @regex: a #GRegex structure
2242  * @string: the string to perform matches against
2243  * @string_len: the length of @string, or -1 if @string is nul-terminated
2244  * @start_position: starting index of the string to match
2245  * @replacement: text to replace each match with
2246  * @match_options: options for the match
2247  * @error: location to store the error occuring, or %NULL to ignore errors
2248  *
2249  * Replaces all occurances of the pattern in @regex with the
2250  * replacement text. @replacement is replaced literally, to
2251  * include backreferences use g_regex_replace().
2252  *
2253  * Setting @start_position differs from just passing over a
2254  * shortened string and setting #G_REGEX_MATCH_NOTBOL in the
2255  * case of a pattern that begins with any kind of lookbehind
2256  * assertion, such as "\b".
2257  *
2258  * Returns: a newly allocated string containing the replacements
2259  *
2260  * Since: 2.14
2261  */
2262 gchar *
2263 g_regex_replace_literal (const GRegex      *regex,
2264                          const gchar       *string,
2265                          gssize             string_len,
2266                          gint               start_position,
2267                          const gchar       *replacement,
2268                          GRegexMatchFlags   match_options,
2269                          GError           **error)
2270 {
2271   g_return_val_if_fail (replacement != NULL, NULL);
2272   g_return_val_if_fail ((match_options & ~G_REGEX_MATCH_MASK) == 0, NULL);
2273
2274   return g_regex_replace_eval (regex,
2275                                string, string_len, start_position,
2276                                match_options,
2277                                literal_replacement,
2278                                (gpointer)replacement,
2279                                error);
2280 }
2281
2282 /**
2283  * g_regex_replace_eval:
2284  * @regex: a #GRegex structure from g_regex_new()
2285  * @string: string to perform matches against
2286  * @string_len: the length of @string, or -1 if @string is nul-terminated
2287  * @start_position: starting index of the string to match
2288  * @match_options: options for the match
2289  * @eval: a function to call for each match
2290  * @user_data: user data to pass to the function
2291  * @error: location to store the error occuring, or %NULL to ignore errors
2292  *
2293  * Replaces occurances of the pattern in regex with the output of
2294  * @eval for that occurance.
2295  *
2296  * Setting @start_position differs from just passing over a shortened
2297  * string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern
2298  * that begins with any kind of lookbehind assertion, such as "\b".
2299  *
2300  * Returns: a newly allocated string containing the replacements
2301  *
2302  * Since: 2.14
2303  */
2304 gchar *
2305 g_regex_replace_eval (const GRegex        *regex,
2306                       const gchar         *string,
2307                       gssize               string_len,
2308                       gint                 start_position,
2309                       GRegexMatchFlags     match_options,
2310                       GRegexEvalCallback   eval,
2311                       gpointer             user_data,
2312                       GError             **error)
2313 {
2314   GMatchInfo *match_info;
2315   GString *result;
2316   gint str_pos = 0;
2317   gboolean done = FALSE;
2318   GError *tmp_error = NULL;
2319
2320   g_return_val_if_fail (regex != NULL, NULL);
2321   g_return_val_if_fail (string != NULL, NULL);
2322   g_return_val_if_fail (start_position >= 0, NULL);
2323   g_return_val_if_fail (eval != NULL, NULL);
2324   g_return_val_if_fail ((match_options & ~G_REGEX_MATCH_MASK) == 0, NULL);
2325
2326   if (string_len < 0)
2327     string_len = strlen (string);
2328
2329   result = g_string_sized_new (string_len);
2330
2331   /* run down the string making matches. */
2332   g_regex_match_full (regex, string, string_len, start_position,
2333                       match_options, &match_info, &tmp_error);
2334   while (!done && g_match_info_matches (match_info))
2335     {
2336       g_string_append_len (result,
2337                            string + str_pos,
2338                            match_info->offsets[0] - str_pos);
2339       done = (*eval) (match_info, result, user_data);
2340       str_pos = match_info->offsets[1];
2341       g_match_info_next (match_info, &tmp_error);
2342     }
2343   g_match_info_free (match_info);
2344   if (tmp_error != NULL)
2345     {
2346       g_propagate_error (error, tmp_error);
2347       g_string_free (result, TRUE);
2348       return NULL;
2349     }
2350
2351   g_string_append_len (result, string + str_pos, string_len - str_pos);
2352   return g_string_free (result, FALSE);
2353 }
2354
2355 /**
2356  * g_regex_check_replacement:
2357  * @replacement: the replacement string
2358  * @has_references: location to store information about
2359  *   references in @replacement or %NULL
2360  * @error: location to store error
2361  *
2362  * Checks whether @replacement is a valid replacement string
2363  * (see g_regex_replace()), i.e. that all escape sequences in
2364  * it are valid.
2365  *
2366  * If @has_references is not %NULL then @replacement is checked
2367  * for pattern references. For instance, replacement text 'foo\n'
2368  * does not contain references and may be evaluated without information
2369  * about actual match, but '\0\1' (whole match followed by first
2370  * subpattern) requires valid #GMatchInfo object.
2371  *
2372  * Returns: whether @replacement is a valid replacement string
2373  *
2374  * Since: 2.14
2375  */
2376 gboolean
2377 g_regex_check_replacement (const gchar  *replacement,
2378                            gboolean     *has_references,
2379                            GError      **error)
2380 {
2381   GList *list;
2382   GError *tmp = NULL;
2383
2384   list = split_replacement (replacement, &tmp);
2385
2386   if (tmp)
2387   {
2388     g_propagate_error (error, tmp);
2389     return FALSE;
2390   }
2391
2392   if (has_references)
2393     *has_references = interpolation_list_needs_match (list);
2394
2395   g_list_foreach (list, (GFunc) free_interpolation_data, NULL);
2396   g_list_free (list);
2397
2398   return TRUE;
2399 }
2400
2401 /**
2402  * g_regex_escape_string:
2403  * @string: the string to escape
2404  * @length: the length of @string, or -1 if @string is nul-terminated
2405  *
2406  * Escapes the special characters used for regular expressions
2407  * in @string, for instance "a.b*c" becomes "a\.b\*c". This
2408  * function is useful to dynamically generate regular expressions.
2409  *
2410  * @string can contain nul characters that are replaced with "\0",
2411  * in this case remember to specify the correct length of @string
2412  * in @length.
2413  *
2414  * Returns: a newly-allocated escaped string
2415  *
2416  * Since: 2.14
2417  */
2418 gchar *
2419 g_regex_escape_string (const gchar *string,
2420                        gint         length)
2421 {
2422   GString *escaped;
2423   const char *p, *piece_start, *end;
2424
2425   g_return_val_if_fail (string != NULL, NULL);
2426
2427   if (length < 0)
2428     length = strlen (string);
2429
2430   end = string + length;
2431   p = piece_start = string;
2432   escaped = g_string_sized_new (length + 1);
2433
2434   while (p < end)
2435     {
2436       switch (*p)
2437         {
2438         case '\0':
2439         case '\\':
2440         case '|':
2441         case '(':
2442         case ')':
2443         case '[':
2444         case ']':
2445         case '{':
2446         case '}':
2447         case '^':
2448         case '$':
2449         case '*':
2450         case '+':
2451         case '?':
2452         case '.':
2453           if (p != piece_start)
2454             /* copy the previous piece. */
2455             g_string_append_len (escaped, piece_start, p - piece_start);
2456           g_string_append_c (escaped, '\\');
2457           if (*p == '\0')
2458             g_string_append_c (escaped, '0');
2459           else
2460             g_string_append_c (escaped, *p);
2461           piece_start = ++p;
2462           break;
2463         default:
2464           p = g_utf8_next_char (p);
2465           break;
2466         }
2467   }
2468
2469   if (piece_start < end)
2470     g_string_append_len (escaped, piece_start, end - piece_start);
2471
2472   return g_string_free (escaped, FALSE);
2473 }
2474
2475 #define __G_REGEX_C__
2476 #include "galiasdef.c"