luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2025-01-12 23:46:17 +01:00
Code Issues Packages Projects Releases Wiki Activity

replace pcre1 with pcre2

Browse Source
This commit is contained in:
Aleksei Rybalkin 2022-07-12 11:46:34 +00:00 committed by Philip Withnall
parent e5f3b08b54
commit 8d5a44dc8f
16 changed files with 846 additions and 626 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
.gitlab-ci.yml
View File

@ -10,10 +10,10 @@ cache:
- _ccache/ - _ccache/
variables: variables:
FEDORA_IMAGE: "registry.gitlab.gnome.org/gnome/glib/fedora:v17" FEDORA_IMAGE: "registry.gitlab.gnome.org/gnome/glib/fedora:v18"
COVERITY_IMAGE: "registry.gitlab.gnome.org/gnome/glib/coverity:v6" COVERITY_IMAGE: "registry.gitlab.gnome.org/gnome/glib/coverity:v7"
DEBIAN_IMAGE: "registry.gitlab.gnome.org/gnome/glib/debian-stable:v12" DEBIAN_IMAGE: "registry.gitlab.gnome.org/gnome/glib/debian-stable:v13"
MINGW_IMAGE: "registry.gitlab.gnome.org/gnome/glib/mingw:v8" MINGW_IMAGE: "registry.gitlab.gnome.org/gnome/glib/mingw:v9"
MESON_TEST_TIMEOUT_MULTIPLIER: 2 MESON_TEST_TIMEOUT_MULTIPLIER: 2
G_MESSAGES_DEBUG: all G_MESSAGES_DEBUG: all
MESON_COMMON_OPTIONS: "--buildtype debug --wrap-mode=nodownload --fatal-meson-warnings" MESON_COMMON_OPTIONS: "--buildtype debug --wrap-mode=nodownload --fatal-meson-warnings"

2
.gitlab-ci/coverity.Dockerfile
View File

@ -1,4 +1,4 @@
FROM registry.gitlab.gnome.org/gnome/glib/fedora:v17 FROM registry.gitlab.gnome.org/gnome/glib/fedora:v18
ARG COVERITY_SCAN_PROJECT_NAME ARG COVERITY_SCAN_PROJECT_NAME
ARG COVERITY_SCAN_TOKEN ARG COVERITY_SCAN_TOKEN

1
.gitlab-ci/debian-stable.Dockerfile
View File

@ -26,7 +26,6 @@ RUN apt-get update -qq && apt-get install --no-install-recommends -qq -y \
libelf-dev \ libelf-dev \
libffi-dev \ libffi-dev \
libmount-dev \ libmount-dev \
libpcre3-dev \
libpcre2-dev \ libpcre2-dev \
libselinux1-dev \ libselinux1-dev \
libxml2-utils \ libxml2-utils \

1
.gitlab-ci/fedora.Dockerfile
View File

@ -43,7 +43,6 @@ RUN dnf -y update \
libxslt \ libxslt \
ncurses-compat-libs \ ncurses-compat-libs \
ninja-build \ ninja-build \
pcre-devel \
pcre2-devel \ pcre2-devel \
"python3-dbusmock >= 0.18.3-2" \ "python3-dbusmock >= 0.18.3-2" \
python3-pip \ python3-pip \

1
.gitlab-ci/mingw.Dockerfile
View File

@ -43,7 +43,6 @@ RUN dnf -y install \
mingw64-zlib \ mingw64-zlib \
ncurses-compat-libs \ ncurses-compat-libs \
ninja-build \ ninja-build \
pcre-devel \
pcre2-devel \ pcre2-devel \
python3 \ python3 \
python3-pip \ python3-pip \

1
.gitlab-ci/test-msys2.sh
View File

@ -18,7 +18,6 @@ pacman --noconfirm -S --needed \
mingw-w64-$MSYS2_ARCH-gettext \ mingw-w64-$MSYS2_ARCH-gettext \
mingw-w64-$MSYS2_ARCH-libffi \ mingw-w64-$MSYS2_ARCH-libffi \
mingw-w64-$MSYS2_ARCH-meson \ mingw-w64-$MSYS2_ARCH-meson \
mingw-w64-$MSYS2_ARCH-pcre \
mingw-w64-$MSYS2_ARCH-pcre2 \ mingw-w64-$MSYS2_ARCH-pcre2 \
mingw-w64-$MSYS2_ARCH-python3 \ mingw-w64-$MSYS2_ARCH-python3 \
mingw-w64-$MSYS2_ARCH-python-pip \ mingw-w64-$MSYS2_ARCH-python-pip \

46
docs/reference/glib/regex-syntax.xml
View File

@ -2442,52 +2442,6 @@ processing option does not affect the called subpattern.
</para> </para>
</refsect1> </refsect1>
<!-- Callouts are not supported by GRegex
<refsect1>
<title>Callouts</title>
<para>
Perl has a feature whereby using the sequence (?{...}) causes arbitrary
Perl code to be obeyed in the middle of matching a regular expression.
This makes it possible, amongst other things, to extract different substrings that match the same pair of parentheses when there is a repetition.
</para>
<para>
PCRE provides a similar feature, but of course it cannot obey arbitrary
Perl code. The feature is called "callout". The caller of PCRE provides
an external function by putting its entry point in the global variable
pcre_callout. By default, this variable contains NULL, which disables
all calling out.
</para>
<para>
Within a regular expression, (?C) indicates the points at which the
external function is to be called. If you want to identify different
callout points, you can put a number less than 256 after the letter C.
The default value is zero. For example, this pattern has two callout
points:
</para>
<programlisting>
(?C1)abc(?C2)def
</programlisting>
<para>
If the PCRE_AUTO_CALLOUT flag is passed to pcre_compile(), callouts are
automatically installed before each item in the pattern. They are all
numbered 255.
</para>
<para>
During matching, when PCRE reaches a callout point (and pcre_callout is
set), the external function is called. It is provided with the number
of the callout, the position in the pattern, and, optionally, one item
of data originally supplied by the caller of pcre_exec(). The callout
function may cause matching to proceed, to backtrack, or to fail altogether. A complete description of the interface to the callout function
is given in the pcrecallout documentation.
</para>
</refsect1>
-->
<refsect1> <refsect1>
<title>Copyright</title> <title>Copyright</title>
<para> <para>

1149
glib/gregex.c
View File

File diff suppressed because it is too large Load Diff

11
glib/gregex.h
View File

@ -264,7 +264,9 @@ GQuark g_regex_error_quark (void);
* in the usual way). * in the usual way).
* @G_REGEX_OPTIMIZE: Optimize the regular expression. If the pattern will * @G_REGEX_OPTIMIZE: Optimize the regular expression. If the pattern will
* be used many times, then it may be worth the effort to optimize it * be used many times, then it may be worth the effort to optimize it
* to improve the speed of matches. * to improve the speed of matches. Deprecated in GLib 2.74 which now uses
* libpcre2, which doesn’t require separate optimization of queries. This
* option is now a no-op. Deprecated: 2.74
* @G_REGEX_FIRSTLINE: Limits an unanchored pattern to match before (or at) the * @G_REGEX_FIRSTLINE: Limits an unanchored pattern to match before (or at) the
* first newline. Since: 2.34 * first newline. Since: 2.34
* @G_REGEX_DUPNAMES: Names used to identify capturing subpatterns need not * @G_REGEX_DUPNAMES: Names used to identify capturing subpatterns need not
@ -287,7 +289,8 @@ GQuark g_regex_error_quark (void);
* is recognised. If this option is set, then "\R" only recognizes the newline * is recognised. If this option is set, then "\R" only recognizes the newline
* characters '\r', '\n' and '\r\n'. Since: 2.34 * characters '\r', '\n' and '\r\n'. Since: 2.34
* @G_REGEX_JAVASCRIPT_COMPAT: Changes behaviour so that it is compatible with * @G_REGEX_JAVASCRIPT_COMPAT: Changes behaviour so that it is compatible with
* JavaScript rather than PCRE. Since: 2.34 * JavaScript rather than PCRE. Since GLib 2.74 this is no longer supported,
* as libpcre2 does not support it. Since: 2.34 Deprecated: 2.74
* *
* Flags specifying compile-time options. * Flags specifying compile-time options.
* *
@ -308,7 +311,7 @@ typedef enum
G_REGEX_UNGREEDY = 1 << 9, G_REGEX_UNGREEDY = 1 << 9,
G_REGEX_RAW = 1 << 11, G_REGEX_RAW = 1 << 11,
G_REGEX_NO_AUTO_CAPTURE = 1 << 12, G_REGEX_NO_AUTO_CAPTURE = 1 << 12,
G_REGEX_OPTIMIZE = 1 << 13, G_REGEX_OPTIMIZE GLIB_DEPRECATED_ENUMERATOR_IN_2_74 = 1 << 13,
G_REGEX_FIRSTLINE = 1 << 18, G_REGEX_FIRSTLINE = 1 << 18,
G_REGEX_DUPNAMES = 1 << 19, G_REGEX_DUPNAMES = 1 << 19,
G_REGEX_NEWLINE_CR = 1 << 20, G_REGEX_NEWLINE_CR = 1 << 20,
@ -316,7 +319,7 @@ typedef enum
G_REGEX_NEWLINE_CRLF = G_REGEX_NEWLINE_CR | G_REGEX_NEWLINE_LF, G_REGEX_NEWLINE_CRLF = G_REGEX_NEWLINE_CR | G_REGEX_NEWLINE_LF,
G_REGEX_NEWLINE_ANYCRLF = G_REGEX_NEWLINE_CR | 1 << 22, G_REGEX_NEWLINE_ANYCRLF = G_REGEX_NEWLINE_CR | 1 << 22,
G_REGEX_BSR_ANYCRLF = 1 << 23, G_REGEX_BSR_ANYCRLF = 1 << 23,
G_REGEX_JAVASCRIPT_COMPAT = 1 << 25 G_REGEX_JAVASCRIPT_COMPAT GLIB_DEPRECATED_ENUMERATOR_IN_2_74 = 1 << 25
} GRegexCompileFlags; } GRegexCompileFlags;
/** /**

10
glib/meson.build
View File

@ -357,13 +357,13 @@ else
glib_dtrace_hdr = [] glib_dtrace_hdr = []
endif endif
pcre_static_args = [] pcre2_static_args = []
if use_pcre_static_flag if use_pcre2_static_flag
pcre_static_args = ['-DPCRE_STATIC'] pcre2_static_args = ['-DPCRE2_STATIC']
endif endif
glib_c_args = ['-DG_LOG_DOMAIN="GLib"', '-DGLIB_COMPILATION'] + pcre_static_args + glib_hidden_visibility_args glib_c_args = ['-DG_LOG_DOMAIN="GLib"', '-DGLIB_COMPILATION'] + pcre2_static_args + glib_hidden_visibility_args
libglib = library('glib-2.0', libglib = library('glib-2.0',
glib_dtrace_obj, glib_dtrace_hdr, glib_dtrace_obj, glib_dtrace_hdr,
sources : [deprecated_sources, glib_sources], sources : [deprecated_sources, glib_sources],
@ -375,7 +375,7 @@ libglib = library('glib-2.0',
link_args : [noseh_link_args, glib_link_flags, win32_ldflags], link_args : [noseh_link_args, glib_link_flags, win32_ldflags],
include_directories : configinc, include_directories : configinc,
link_with: [charset_lib, gnulib_lib], link_with: [charset_lib, gnulib_lib],
dependencies : [pcre, thread_dep, librt] + libintl_deps + libiconv + platform_deps + [gnulib_libm_dependency, libm] + [libsysprof_capture_dep], dependencies : [pcre2, thread_dep, librt] + libintl_deps + libiconv + platform_deps + [gnulib_libm_dependency, libm] + [libsysprof_capture_dep],
c_args : glib_c_args, c_args : glib_c_args,
objc_args : glib_c_args, objc_args : glib_c_args,
) )

4
glib/tests/meson.build
View File

@ -89,8 +89,8 @@ glib_tests = {
}, },
'refstring' : {}, 'refstring' : {},
'regex' : { 'regex' : {
'dependencies' : [pcre], 'dependencies' : [pcre2],
'c_args' : use_pcre_static_flag ? ['-DPCRE_STATIC'] : [], 'c_args' : use_pcre2_static_flag ? ['-DPCRE2_STATIC'] : [],
}, },
'relation' : {}, 'relation' : {},
'rwlock' : {}, 'rwlock' : {},

175
glib/tests/regex.c
View File

@ -27,7 +27,8 @@
#include <locale.h> #include <locale.h>
#include "glib.h" #include "glib.h"
#include <pcre.h> #define PCRE2_CODE_UNIT_WIDTH 8
#include <pcre2.h>
/* U+20AC EURO SIGN (symbol, currency) */ /* U+20AC EURO SIGN (symbol, currency) */
#define EURO "\xe2\x82\xac" #define EURO "\xe2\x82\xac"
@ -1503,7 +1504,7 @@ test_properties (void)
gchar *str; gchar *str;
error = NULL; error = NULL;
regex = g_regex_new ("\\p{L}\\p{Ll}\\p{Lu}\\p{L&}\\p{N}\\p{Nd}", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("\\p{L}\\p{Ll}\\p{Lu}\\p{L&}\\p{N}\\p{Nd}", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
res = g_regex_match (regex, "ppPP01", 0, &match); res = g_regex_match (regex, "ppPP01", 0, &match);
g_assert (res); g_assert (res);
str = g_match_info_fetch (match, 0); str = g_match_info_fetch (match, 0);
@ -1524,7 +1525,7 @@ test_class (void)
gchar *str; gchar *str;
error = NULL; error = NULL;
regex = g_regex_new ("[abc\\x{0B1E}\\p{Mn}\\x{0391}-\\x{03A9}]", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("[abc\\x{0B1E}\\p{Mn}\\x{0391}-\\x{03A9}]", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
res = g_regex_match (regex, "a:b:\340\254\236:\333\253:\316\240", 0, &match); res = g_regex_match (regex, "a:b:\340\254\236:\333\253:\316\240", 0, &match);
g_assert (res); g_assert (res);
str = g_match_info_fetch (match, 0); str = g_match_info_fetch (match, 0);
@ -1570,7 +1571,7 @@ test_lookahead (void)
gint start, end; gint start, end;
error = NULL; error = NULL;
regex = g_regex_new ("\\w+(?=;)", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("\\w+(?=;)", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "word1 word2: word3;", 0, &match); res = g_regex_match (regex, "word1 word2: word3;", 0, &match);
@ -1584,7 +1585,7 @@ test_lookahead (void)
g_regex_unref (regex); g_regex_unref (regex);
error = NULL; error = NULL;
regex = g_regex_new ("foo(?!bar)", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("foo(?!bar)", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "foobar foobaz", 0, &match); res = g_regex_match (regex, "foobar foobaz", 0, &match);
@ -1599,7 +1600,7 @@ test_lookahead (void)
g_regex_unref (regex); g_regex_unref (regex);
error = NULL; error = NULL;
regex = g_regex_new ("(?!bar)foo", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("(?!bar)foo", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "foobar foobaz", 0, &match); res = g_regex_match (regex, "foobar foobaz", 0, &match);
@ -1632,7 +1633,7 @@ test_lookbehind (void)
gint start, end; gint start, end;
error = NULL; error = NULL;
regex = g_regex_new ("(?<!foo)bar", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("(?<!foo)bar", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "foobar boobar", 0, &match); res = g_regex_match (regex, "foobar boobar", 0, &match);
@ -1647,7 +1648,7 @@ test_lookbehind (void)
g_regex_unref (regex); g_regex_unref (regex);
error = NULL; error = NULL;
regex = g_regex_new ("(?<=bullock|donkey) poo", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("(?<=bullock|donkey) poo", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "don poo, and bullock poo", 0, &match); res = g_regex_match (regex, "don poo, and bullock poo", 0, &match);
@ -1660,17 +1661,17 @@ test_lookbehind (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("(?<!dogs?|cats?) x", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("(?<!dogs?|cats?) x", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex == NULL); g_assert (regex == NULL);
g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND); g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND);
g_clear_error (&error); g_clear_error (&error);
regex = g_regex_new ("(?<=ab(c|de)) foo", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("(?<=ab(c|de)) foo", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex == NULL); g_assert (regex == NULL);
g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND); g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND);
g_clear_error (&error); g_clear_error (&error);
regex = g_regex_new ("(?<=abc|abde)foo", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("(?<=abc|abde)foo", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "abfoo, abdfoo, abcfoo", 0, &match); res = g_regex_match (regex, "abfoo, abdfoo, abcfoo", 0, &match);
@ -1682,7 +1683,7 @@ test_lookbehind (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("^.*+(?<=abcd)", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("^.*+(?<=abcd)", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "abcabcabcabcabcabcabcabcabcd", 0, &match); res = g_regex_match (regex, "abcabcabcabcabcabcabcabcabcd", 0, &match);
@ -1691,7 +1692,7 @@ test_lookbehind (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("(?<=\\d{3})(?<!999)foo", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("(?<=\\d{3})(?<!999)foo", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "999foo 123abcfoo 123foo", 0, &match); res = g_regex_match (regex, "999foo 123abcfoo 123foo", 0, &match);
@ -1703,7 +1704,7 @@ test_lookbehind (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("(?<=\\d{3}...)(?<!999)foo", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("(?<=\\d{3}...)(?<!999)foo", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "999foo 123abcfoo 123foo", 0, &match); res = g_regex_match (regex, "999foo 123abcfoo 123foo", 0, &match);
@ -1715,7 +1716,7 @@ test_lookbehind (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("(?<=\\d{3}(?!999)...)foo", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("(?<=\\d{3}(?!999)...)foo", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "999foo 123abcfoo 123foo", 0, &match); res = g_regex_match (regex, "999foo 123abcfoo 123foo", 0, &match);
@ -1727,7 +1728,7 @@ test_lookbehind (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("(?<=(?<!foo)bar)baz", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("(?<=(?<!foo)bar)baz", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "foobarbaz barfoobaz barbarbaz", 0, &match); res = g_regex_match (regex, "foobarbaz barfoobaz barbarbaz", 0, &match);
@ -1752,7 +1753,7 @@ test_subpattern (void)
gint start; gint start;
error = NULL; error = NULL;
regex = g_regex_new ("cat(aract|erpillar|)", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("cat(aract|erpillar|)", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
g_assert_cmpint (g_regex_get_capture_count (regex), ==, 1); g_assert_cmpint (g_regex_get_capture_count (regex), ==, 1);
@ -1770,7 +1771,7 @@ test_subpattern (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("the ((red|white) (king|queen))", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("the ((red|white) (king|queen))", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
g_assert_cmpint (g_regex_get_capture_count (regex), ==, 3); g_assert_cmpint (g_regex_get_capture_count (regex), ==, 3);
@ -1794,7 +1795,7 @@ test_subpattern (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("the ((?:red|white) (king|queen))", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("the ((?:red|white) (king|queen))", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "the white queen", 0, &match); res = g_regex_match (regex, "the white queen", 0, &match);
@ -1814,7 +1815,7 @@ test_subpattern (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("(?|(Sat)(ur)|(Sun))day (morning|afternoon)", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("(?|(Sat)(ur)|(Sun))day (morning|afternoon)", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
g_assert_cmpint (g_regex_get_capture_count (regex), ==, 3); g_assert_cmpint (g_regex_get_capture_count (regex), ==, 3);
@ -1834,7 +1835,7 @@ test_subpattern (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("(?|(abc)|(def))\\1", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("(?|(abc)|(def))\\1", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
g_assert_cmpint (g_regex_get_max_backref (regex), ==, 1); g_assert_cmpint (g_regex_get_max_backref (regex), ==, 1);
@ -1852,7 +1853,7 @@ test_subpattern (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("(?|(abc)|(def))(?1)", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("(?|(abc)|(def))(?1)", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "abcabc abcdef defabc defdef", 0, &match); res = g_regex_match (regex, "abcabc abcdef defabc defdef", 0, &match);
@ -1869,7 +1870,7 @@ test_subpattern (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("(?<DN>Mon|Fri|Sun)(?:day)?|(?<DN>Tue)(?:sday)?|(?<DN>Wed)(?:nesday)?|(?<DN>Thu)(?:rsday)?|(?<DN>Sat)(?:urday)?", G_REGEX_OPTIMIZE|G_REGEX_DUPNAMES, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("(?<DN>Mon|Fri|Sun)(?:day)?|(?<DN>Tue)(?:sday)?|(?<DN>Wed)(?:nesday)?|(?<DN>Thu)(?:rsday)?|(?<DN>Sat)(?:urday)?", G_REGEX_DUPNAMES, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "Mon Tuesday Wed Saturday", 0, &match); res = g_regex_match (regex, "Mon Tuesday Wed Saturday", 0, &match);
@ -1896,7 +1897,7 @@ test_subpattern (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("^(a|b\\1)+$", G_REGEX_OPTIMIZE|G_REGEX_DUPNAMES, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("^(a|b\\1)+$", G_REGEX_DUPNAMES, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "aaaaaaaaaaaaaaaa", 0, &match); res = g_regex_match (regex, "aaaaaaaaaaaaaaaa", 0, &match);
@ -1920,7 +1921,7 @@ test_condition (void)
gboolean res; gboolean res;
error = NULL; error = NULL;
regex = g_regex_new ("^(a+)(\\()?[^()]+(?(-1)\\))(b+)$", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("^(a+)(\\()?[^()]+(?(-1)\\))(b+)$", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "a(zzzzzz)b", 0, &match); res = g_regex_match (regex, "a(zzzzzz)b", 0, &match);
@ -1934,7 +1935,7 @@ test_condition (void)
g_regex_unref (regex); g_regex_unref (regex);
error = NULL; error = NULL;
regex = g_regex_new ("^(a+)(?<OPEN>\\()?[^()]+(?(<OPEN>)\\))(b+)$", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("^(a+)(?<OPEN>\\()?[^()]+(?(<OPEN>)\\))(b+)$", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "a(zzzzzz)b", 0, &match); res = g_regex_match (regex, "a(zzzzzz)b", 0, &match);
@ -1947,7 +1948,7 @@ test_condition (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("^(a+)(?(+1)\\[|\\<)?[^()]+(\\])?(b+)$", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("^(a+)(?(+1)\\[|\\<)?[^()]+(\\])?(b+)$", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "a[zzzzzz]b", 0, &match); res = g_regex_match (regex, "a[zzzzzz]b", 0, &match);
@ -1962,7 +1963,7 @@ test_condition (void)
regex = g_regex_new ("(?(DEFINE) (?<byte> 2[0-4]\\d | 25[0-5] | 1\\d\\d | [1-9]?\\d) )" regex = g_regex_new ("(?(DEFINE) (?<byte> 2[0-4]\\d | 25[0-5] | 1\\d\\d | [1-9]?\\d) )"
"\\b (?&byte) (\\.(?&byte)){3} \\b", "\\b (?&byte) (\\.(?&byte)){3} \\b",
G_REGEX_OPTIMIZE|G_REGEX_EXTENDED, 0, &error); G_REGEX_EXTENDED, 0, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "128.0.0.1", 0, &match); res = g_regex_match (regex, "128.0.0.1", 0, &match);
@ -1981,7 +1982,7 @@ test_condition (void)
regex = g_regex_new ("^(?(?=[^a-z]*[a-z])" regex = g_regex_new ("^(?(?=[^a-z]*[a-z])"
"\\d{2}-[a-z]{3}-\\d{2} | \\d{2}-\\d{2}-\\d{2} )$", "\\d{2}-[a-z]{3}-\\d{2} | \\d{2}-\\d{2}-\\d{2} )$",
G_REGEX_OPTIMIZE|G_REGEX_EXTENDED, 0, &error); G_REGEX_EXTENDED, 0, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "01-abc-24", 0, &match); res = g_regex_match (regex, "01-abc-24", 0, &match);
@ -2014,7 +2015,7 @@ test_recursion (void)
gint start; gint start;
error = NULL; error = NULL;
regex = g_regex_new ("\\( ( [^()]++ | (?R) )* \\)", G_REGEX_OPTIMIZE|G_REGEX_EXTENDED, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("\\( ( [^()]++ | (?R) )* \\)", G_REGEX_EXTENDED, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "(middle)", 0, &match); res = g_regex_match (regex, "(middle)", 0, &match);
@ -2031,7 +2032,7 @@ test_recursion (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("^( \\( ( [^()]++ | (?1) )* \\) )$", G_REGEX_OPTIMIZE|G_REGEX_EXTENDED, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("^( \\( ( [^()]++ | (?1) )* \\) )$", G_REGEX_EXTENDED, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "((((((((((((((((middle))))))))))))))))", 0, &match); res = g_regex_match (regex, "((((((((((((((((middle))))))))))))))))", 0, &match);
@ -2044,7 +2045,7 @@ test_recursion (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("^(?<pn> \\( ( [^()]++ | (?&pn) )* \\) )$", G_REGEX_OPTIMIZE|G_REGEX_EXTENDED, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("^(?<pn> \\( ( [^()]++ | (?&pn) )* \\) )$", G_REGEX_EXTENDED, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
g_regex_match (regex, "(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()", 0, &match); g_regex_match (regex, "(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()", 0, &match);
@ -2053,7 +2054,7 @@ test_recursion (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("< (?: (?(R) \\d++ | [^<>]*+) | (?R)) * >", G_REGEX_OPTIMIZE|G_REGEX_EXTENDED, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("< (?: (?(R) \\d++ | [^<>]*+) | (?R)) * >", G_REGEX_EXTENDED, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "<ab<01<23<4>>>>", 0, &match); res = g_regex_match (regex, "<ab<01<23<4>>>>", 0, &match);
@ -2072,7 +2073,7 @@ test_recursion (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("^((.)(?1)\\2|.)$", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("^((.)(?1)\\2|.)$", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "abcdcba", 0, &match); res = g_regex_match (regex, "abcdcba", 0, &match);
@ -2085,7 +2086,7 @@ test_recursion (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("^(?:((.)(?1)\\2|)|((.)(?3)\\4|.))$", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("^(?:((.)(?1)\\2|)|((.)(?3)\\4|.))$", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "abcdcba", 0, &match); res = g_regex_match (regex, "abcdcba", 0, &match);
@ -2098,7 +2099,7 @@ test_recursion (void)
g_match_info_free (match); g_match_info_free (match);
g_regex_unref (regex); g_regex_unref (regex);
regex = g_regex_new ("^\\W*+(?:((.)\\W*+(?1)\\W*+\\2|)|((.)\\W*+(?3)\\W*+\\4|\\W*+.\\W*+))\\W*+$", G_REGEX_OPTIMIZE|G_REGEX_CASELESS, G_REGEX_MATCH_DEFAULT, &error); regex = g_regex_new ("^\\W*+(?:((.)\\W*+(?1)\\W*+\\2|)|((.)\\W*+(?3)\\W*+\\4|\\W*+.\\W*+))\\W*+$", G_REGEX_CASELESS, G_REGEX_MATCH_DEFAULT, &error);
g_assert (regex); g_assert (regex);
g_assert_no_error (error); g_assert_no_error (error);
res = g_regex_match (regex, "abcdcba", 0, &match); res = g_regex_match (regex, "abcdcba", 0, &match);
@ -2169,21 +2170,21 @@ test_max_lookbehind (void)
} }
static gboolean static gboolean
pcre_ge (guint64 major, guint64 minor) pcre2_ge (guint64 major, guint64 minor)
{ {
const char *version; gchar version[32];
gchar *ptr; const gchar *ptr;
guint64 pcre_major, pcre_minor; guint64 pcre2_major, pcre2_minor;
/* e.g. 8.35 2014-04-04 */ /* e.g. 10.36 2020-12-04 */
version = pcre_version (); pcre2_config (PCRE2_CONFIG_VERSION, version);
pcre_major = g_ascii_strtoull (version, &ptr, 10); pcre2_major = g_ascii_strtoull (version, (gchar **) &ptr, 10);
/* ptr points to ".MINOR (release date)" */ /* ptr points to ".MINOR (release date)" */
g_assert (ptr[0] == '.'); g_assert (ptr[0] == '.');
pcre_minor = g_ascii_strtoull (ptr + 1, NULL, 10); pcre2_minor = g_ascii_strtoull (ptr + 1, NULL, 10);
return (pcre_major > major) || (pcre_major == major && pcre_minor >= minor); return (pcre2_major > major) || (pcre2_major == major && pcre2_minor >= minor);
} }
int int
@ -2205,18 +2206,26 @@ main (int argc, char *argv[])
g_test_add_func ("/regex/max-lookbehind", test_max_lookbehind); g_test_add_func ("/regex/max-lookbehind", test_max_lookbehind);
/* TEST_NEW(pattern, compile_opts, match_opts) */ /* TEST_NEW(pattern, compile_opts, match_opts) */
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
TEST_NEW("[A-Z]+", G_REGEX_CASELESS | G_REGEX_EXTENDED | G_REGEX_OPTIMIZE, G_REGEX_MATCH_NOTBOL | G_REGEX_MATCH_PARTIAL); TEST_NEW("[A-Z]+", G_REGEX_CASELESS | G_REGEX_EXTENDED | G_REGEX_OPTIMIZE, G_REGEX_MATCH_NOTBOL | G_REGEX_MATCH_PARTIAL);
G_GNUC_END_IGNORE_DEPRECATIONS
TEST_NEW("", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT); TEST_NEW("", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT);
TEST_NEW(".*", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT); TEST_NEW(".*", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
TEST_NEW(".*", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT); TEST_NEW(".*", G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT);
G_GNUC_END_IGNORE_DEPRECATIONS
TEST_NEW(".*", G_REGEX_MULTILINE, G_REGEX_MATCH_DEFAULT); TEST_NEW(".*", G_REGEX_MULTILINE, G_REGEX_MATCH_DEFAULT);
TEST_NEW(".*", G_REGEX_DOTALL, G_REGEX_MATCH_DEFAULT); TEST_NEW(".*", G_REGEX_DOTALL, G_REGEX_MATCH_DEFAULT);
TEST_NEW(".*", G_REGEX_DOTALL, G_REGEX_MATCH_NOTBOL); TEST_NEW(".*", G_REGEX_DOTALL, G_REGEX_MATCH_NOTBOL);
TEST_NEW("(123\\d*)[a-zA-Z]+(?P<hello>.*)", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT); TEST_NEW("(123\\d*)[a-zA-Z]+(?P<hello>.*)", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT);
TEST_NEW("(123\\d*)[a-zA-Z]+(?P<hello>.*)", G_REGEX_CASELESS, G_REGEX_MATCH_DEFAULT); TEST_NEW("(123\\d*)[a-zA-Z]+(?P<hello>.*)", G_REGEX_CASELESS, G_REGEX_MATCH_DEFAULT);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
TEST_NEW("(123\\d*)[a-zA-Z]+(?P<hello>.*)", G_REGEX_CASELESS | G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT); TEST_NEW("(123\\d*)[a-zA-Z]+(?P<hello>.*)", G_REGEX_CASELESS | G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT);
G_GNUC_END_IGNORE_DEPRECATIONS
TEST_NEW("(?P<A>x)|(?P<A>y)", G_REGEX_DUPNAMES, G_REGEX_MATCH_DEFAULT); TEST_NEW("(?P<A>x)|(?P<A>y)", G_REGEX_DUPNAMES, G_REGEX_MATCH_DEFAULT);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
TEST_NEW("(?P<A>x)|(?P<A>y)", G_REGEX_DUPNAMES | G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT); TEST_NEW("(?P<A>x)|(?P<A>y)", G_REGEX_DUPNAMES | G_REGEX_OPTIMIZE, G_REGEX_MATCH_DEFAULT);
G_GNUC_END_IGNORE_DEPRECATIONS
/* This gives "internal error: code overflow" with pcre 6.0 */ /* This gives "internal error: code overflow" with pcre 6.0 */
TEST_NEW("(?i)(?-i)", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT); TEST_NEW("(?i)(?-i)", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT);
TEST_NEW ("(?i)a", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT); TEST_NEW ("(?i)a", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT);
@ -2227,9 +2236,10 @@ main (int argc, char *argv[])
TEST_NEW ("(?U)[a-z]+", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT); TEST_NEW ("(?U)[a-z]+", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT);
/* TEST_NEW_CHECK_FLAGS(pattern, compile_opts, match_ops, real_compile_opts, real_match_opts) */ /* TEST_NEW_CHECK_FLAGS(pattern, compile_opts, match_ops, real_compile_opts, real_match_opts) */
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
TEST_NEW_CHECK_FLAGS ("a", G_REGEX_OPTIMIZE, 0, G_REGEX_OPTIMIZE, 0); TEST_NEW_CHECK_FLAGS ("a", G_REGEX_OPTIMIZE, 0, G_REGEX_OPTIMIZE, 0);
G_GNUC_END_IGNORE_DEPRECATIONS
TEST_NEW_CHECK_FLAGS ("a", G_REGEX_RAW, 0, G_REGEX_RAW, 0); TEST_NEW_CHECK_FLAGS ("a", G_REGEX_RAW, 0, G_REGEX_RAW, 0);
TEST_NEW_CHECK_FLAGS ("(?X)a", 0, 0, 0 /* not exposed by GRegex */, 0);
TEST_NEW_CHECK_FLAGS ("^.*", 0, 0, G_REGEX_ANCHORED, 0); TEST_NEW_CHECK_FLAGS ("^.*", 0, 0, G_REGEX_ANCHORED, 0);
TEST_NEW_CHECK_FLAGS ("(*UTF8)a", 0, 0, 0 /* this is the default in GRegex */, 0); TEST_NEW_CHECK_FLAGS ("(*UTF8)a", 0, 0, 0 /* this is the default in GRegex */, 0);
TEST_NEW_CHECK_FLAGS ("(*UCP)a", 0, 0, 0 /* this always on in GRegex */, 0); TEST_NEW_CHECK_FLAGS ("(*UCP)a", 0, 0, 0 /* this always on in GRegex */, 0);
@ -2257,16 +2267,16 @@ main (int argc, char *argv[])
TEST_NEW_FAIL ("a{4,2}", 0, G_REGEX_ERROR_QUANTIFIERS_OUT_OF_ORDER); TEST_NEW_FAIL ("a{4,2}", 0, G_REGEX_ERROR_QUANTIFIERS_OUT_OF_ORDER);
TEST_NEW_FAIL ("a{999999,}", 0, G_REGEX_ERROR_QUANTIFIER_TOO_BIG); TEST_NEW_FAIL ("a{999999,}", 0, G_REGEX_ERROR_QUANTIFIER_TOO_BIG);
TEST_NEW_FAIL ("[a-z", 0, G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS); TEST_NEW_FAIL ("[a-z", 0, G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS);
TEST_NEW_FAIL ("(?X)[\\B]", 0, G_REGEX_ERROR_INVALID_ESCAPE_IN_CHARACTER_CLASS); TEST_NEW_FAIL ("[\\B]", 0, G_REGEX_ERROR_INVALID_ESCAPE_IN_CHARACTER_CLASS);
TEST_NEW_FAIL ("[z-a]", 0, G_REGEX_ERROR_RANGE_OUT_OF_ORDER); TEST_NEW_FAIL ("[z-a]", 0, G_REGEX_ERROR_RANGE_OUT_OF_ORDER);
TEST_NEW_FAIL ("{2,4}", 0, G_REGEX_ERROR_NOTHING_TO_REPEAT); TEST_NEW_FAIL ("{2,4}", 0, G_REGEX_ERROR_NOTHING_TO_REPEAT);
TEST_NEW_FAIL ("a(?u)", 0, G_REGEX_ERROR_UNRECOGNIZED_CHARACTER); TEST_NEW_FAIL ("a(?u)", 0, G_REGEX_ERROR_UNRECOGNIZED_CHARACTER);
TEST_NEW_FAIL ("a(?<$foo)bar", 0, G_REGEX_ERROR_UNRECOGNIZED_CHARACTER); TEST_NEW_FAIL ("a(?<$foo)bar", 0, G_REGEX_ERROR_MISSING_SUBPATTERN_NAME);
TEST_NEW_FAIL ("a[:alpha:]b", 0, G_REGEX_ERROR_POSIX_NAMED_CLASS_OUTSIDE_CLASS); TEST_NEW_FAIL ("a[:alpha:]b", 0, G_REGEX_ERROR_POSIX_NAMED_CLASS_OUTSIDE_CLASS);
TEST_NEW_FAIL ("a(b", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS); TEST_NEW_FAIL ("a(b", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
TEST_NEW_FAIL ("a)b", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS); TEST_NEW_FAIL ("a)b", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
TEST_NEW_FAIL ("a(?R", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS); TEST_NEW_FAIL ("a(?R", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
TEST_NEW_FAIL ("a(?-54", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS); TEST_NEW_FAIL ("a(?-54", 0, G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE);
TEST_NEW_FAIL ("(ab\\2)", 0, G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE); TEST_NEW_FAIL ("(ab\\2)", 0, G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE);
TEST_NEW_FAIL ("a(?#abc", 0, G_REGEX_ERROR_UNTERMINATED_COMMENT); TEST_NEW_FAIL ("a(?#abc", 0, G_REGEX_ERROR_UNTERMINATED_COMMENT);
TEST_NEW_FAIL ("(?<=a+)b", 0, G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND); TEST_NEW_FAIL ("(?<=a+)b", 0, G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND);
@ -2276,51 +2286,31 @@ main (int argc, char *argv[])
TEST_NEW_FAIL ("a[[:fubar:]]b", 0, G_REGEX_ERROR_UNKNOWN_POSIX_CLASS_NAME); TEST_NEW_FAIL ("a[[:fubar:]]b", 0, G_REGEX_ERROR_UNKNOWN_POSIX_CLASS_NAME);
TEST_NEW_FAIL ("[[.ch.]]", 0, G_REGEX_ERROR_POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED); TEST_NEW_FAIL ("[[.ch.]]", 0, G_REGEX_ERROR_POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED);
TEST_NEW_FAIL ("\\x{110000}", 0, G_REGEX_ERROR_HEX_CODE_TOO_LARGE); TEST_NEW_FAIL ("\\x{110000}", 0, G_REGEX_ERROR_HEX_CODE_TOO_LARGE);
TEST_NEW_FAIL ("^(?(0)f|b)oo", 0, G_REGEX_ERROR_INVALID_CONDITION); TEST_NEW_FAIL ("^(?(0)f|b)oo", 0, G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE);
TEST_NEW_FAIL ("(?<=\\C)X", 0, G_REGEX_ERROR_SINGLE_BYTE_MATCH_IN_LOOKBEHIND); TEST_NEW_FAIL ("(?<=\\C)X", 0, G_REGEX_ERROR_SINGLE_BYTE_MATCH_IN_LOOKBEHIND);
TEST_NEW_FAIL ("(?!\\w)(?R)", 0, G_REGEX_ERROR_INFINITE_LOOP); TEST_NEW ("(?!\\w)(?R)", 0, 0);
if (pcre_ge (8, 37)) TEST_NEW_FAIL ("(?(?<ab))", 0, G_REGEX_ERROR_ASSERTION_EXPECTED);
{ TEST_NEW_FAIL ("(?P<sub>foo)\\g<sub", 0, G_REGEX_ERROR_MISSING_SUBPATTERN_NAME_TERMINATOR);
/* The expected errors changed here. */
TEST_NEW_FAIL ("(?(?<ab))", 0, G_REGEX_ERROR_ASSERTION_EXPECTED);
}
else
{
TEST_NEW_FAIL ("(?(?<ab))", 0, G_REGEX_ERROR_MISSING_SUBPATTERN_NAME_TERMINATOR);
}
if (pcre_ge (8, 35))
{
/* The expected errors changed here. */
TEST_NEW_FAIL ("(?P<sub>foo)\\g<sub", 0, G_REGEX_ERROR_MISSING_SUBPATTERN_NAME_TERMINATOR);
}
else
{
TEST_NEW_FAIL ("(?P<sub>foo)\\g<sub", 0, G_REGEX_ERROR_MISSING_BACK_REFERENCE);
}
TEST_NEW_FAIL ("(?P<x>eks)(?P<x>eccs)", 0, G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME); TEST_NEW_FAIL ("(?P<x>eks)(?P<x>eccs)", 0, G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME);
#if 0
TEST_NEW_FAIL (?, 0, G_REGEX_ERROR_MALFORMED_PROPERTY);
TEST_NEW_FAIL (?, 0, G_REGEX_ERROR_UNKNOWN_PROPERTY);
#endif
TEST_NEW_FAIL ("\\666", G_REGEX_RAW, G_REGEX_ERROR_INVALID_OCTAL_VALUE); TEST_NEW_FAIL ("\\666", G_REGEX_RAW, G_REGEX_ERROR_INVALID_OCTAL_VALUE);
TEST_NEW_FAIL ("^(?(DEFINE) abc | xyz ) ", 0, G_REGEX_ERROR_TOO_MANY_BRANCHES_IN_DEFINE); TEST_NEW_FAIL ("^(?(DEFINE) abc | xyz ) ", 0, G_REGEX_ERROR_TOO_MANY_BRANCHES_IN_DEFINE);
TEST_NEW_FAIL ("a", G_REGEX_NEWLINE_CRLF | G_REGEX_NEWLINE_ANYCRLF, G_REGEX_ERROR_INCONSISTENT_NEWLINE_OPTIONS); TEST_NEW_FAIL ("a", G_REGEX_NEWLINE_CRLF | G_REGEX_NEWLINE_ANYCRLF, G_REGEX_ERROR_INCONSISTENT_NEWLINE_OPTIONS);
TEST_NEW_FAIL ("^(a)\\g{3", 0, G_REGEX_ERROR_MISSING_BACK_REFERENCE); TEST_NEW_FAIL ("^(a)\\g{3", 0, G_REGEX_ERROR_MISSING_BACK_REFERENCE);
TEST_NEW_FAIL ("^(a)\\g{0}", 0, G_REGEX_ERROR_INVALID_RELATIVE_REFERENCE); TEST_NEW_FAIL ("^(a)\\g{0}", 0, G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE);
TEST_NEW_FAIL ("abc(*FAIL:123)xyz", 0, G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN); TEST_NEW ("abc(*FAIL:123)xyz", 0, 0);
TEST_NEW_FAIL ("a(*FOOBAR)b", 0, G_REGEX_ERROR_UNKNOWN_BACKTRACKING_CONTROL_VERB); TEST_NEW_FAIL ("a(*FOOBAR)b", 0, G_REGEX_ERROR_UNKNOWN_BACKTRACKING_CONTROL_VERB);
TEST_NEW_FAIL ("(?i:A{1,}\\6666666666)", 0, G_REGEX_ERROR_NUMBER_TOO_BIG); if (pcre2_ge (10, 37))
{
TEST_NEW ("(?i:A{1,}\\6666666666)", 0, 0);
}
TEST_NEW_FAIL ("(?<a>)(?&)", 0, G_REGEX_ERROR_MISSING_SUBPATTERN_NAME); TEST_NEW_FAIL ("(?<a>)(?&)", 0, G_REGEX_ERROR_MISSING_SUBPATTERN_NAME);
TEST_NEW_FAIL ("(?+-a)", 0, G_REGEX_ERROR_MISSING_DIGIT); TEST_NEW_FAIL ("(?+-a)", 0, G_REGEX_ERROR_INVALID_RELATIVE_REFERENCE);
TEST_NEW_FAIL ("TA]", G_REGEX_JAVASCRIPT_COMPAT, G_REGEX_ERROR_INVALID_DATA_CHARACTER);
TEST_NEW_FAIL ("(?|(?<a>A)|(?<b>B))", 0, G_REGEX_ERROR_EXTRA_SUBPATTERN_NAME); TEST_NEW_FAIL ("(?|(?<a>A)|(?<b>B))", 0, G_REGEX_ERROR_EXTRA_SUBPATTERN_NAME);
TEST_NEW_FAIL ("a(*MARK)b", 0, G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED); TEST_NEW_FAIL ("a(*MARK)b", 0, G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED);
TEST_NEW_FAIL ("^\\c€", 0, G_REGEX_ERROR_INVALID_CONTROL_CHAR); TEST_NEW_FAIL ("^\\c€", 0, G_REGEX_ERROR_INVALID_CONTROL_CHAR);
TEST_NEW_FAIL ("\\k", 0, G_REGEX_ERROR_MISSING_NAME); TEST_NEW_FAIL ("\\k", 0, G_REGEX_ERROR_MISSING_NAME);
TEST_NEW_FAIL ("a[\\NB]c", 0, G_REGEX_ERROR_NOT_SUPPORTED_IN_CLASS); TEST_NEW_FAIL ("a[\\NB]c", 0, G_REGEX_ERROR_NOT_SUPPORTED_IN_CLASS);
TEST_NEW_FAIL ("(*:0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEFG)XX", 0, G_REGEX_ERROR_NAME_TOO_LONG); TEST_NEW_FAIL ("(*:0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEFG)XX", 0, G_REGEX_ERROR_NAME_TOO_LONG);
TEST_NEW_FAIL ("\\u0100", G_REGEX_RAW | G_REGEX_JAVASCRIPT_COMPAT, G_REGEX_ERROR_CHARACTER_VALUE_TOO_LARGE);
/* These errors can't really be tested easily: /* These errors can't really be tested easily:
* G_REGEX_ERROR_EXPRESSION_TOO_LARGE * G_REGEX_ERROR_EXPRESSION_TOO_LARGE
@ -2476,7 +2466,15 @@ main (int argc, char *argv[])
TEST_MATCH("a#\nb", G_REGEX_EXTENDED, 0, "a", -1, 0, 0, FALSE); TEST_MATCH("a#\nb", G_REGEX_EXTENDED, 0, "a", -1, 0, 0, FALSE);
TEST_MATCH("a#\r\nb", G_REGEX_EXTENDED, 0, "a", -1, 0, 0, FALSE); TEST_MATCH("a#\r\nb", G_REGEX_EXTENDED, 0, "a", -1, 0, 0, FALSE);
TEST_MATCH("a#\rb", G_REGEX_EXTENDED, 0, "a", -1, 0, 0, FALSE); TEST_MATCH("a#\rb", G_REGEX_EXTENDED, 0, "a", -1, 0, 0, FALSE);
TEST_MATCH("a#\nb", G_REGEX_EXTENDED, G_REGEX_MATCH_NEWLINE_CR, "a", -1, 0, 0, FALSE); /* Due to PCRE2 only supporting newline settings passed to pcre2_compile (and
* not to pcre2_match also), we have to compile the pattern with the
* effective (combined from compile and match options) newline setting.
* However, this setting also affects how newlines are interpreted *inside*
* the pattern. With G_REGEX_EXTENDED, this changes where the comment
* (started with `#`) ends.
*/
/* On PCRE1, this test expected no match; on PCRE2 it matches because of the above. */
TEST_MATCH("a#\nb", G_REGEX_EXTENDED, G_REGEX_MATCH_NEWLINE_CR, "a", -1, 0, 0, TRUE /*FALSE*/);
TEST_MATCH("a#\nb", G_REGEX_EXTENDED | G_REGEX_NEWLINE_CR, 0, "a", -1, 0, 0, TRUE); TEST_MATCH("a#\nb", G_REGEX_EXTENDED | G_REGEX_NEWLINE_CR, 0, "a", -1, 0, 0, TRUE);
TEST_MATCH("line\nbreak", G_REGEX_MULTILINE, 0, "this is a line\nbreak", -1, 0, 0, TRUE); TEST_MATCH("line\nbreak", G_REGEX_MULTILINE, 0, "this is a line\nbreak", -1, 0, 0, TRUE);
@ -2489,21 +2487,19 @@ main (int argc, char *argv[])
* with pcre's internal tables. Bug #678273 */ * with pcre's internal tables. Bug #678273 */
TEST_MATCH("[DŽ]", G_REGEX_CASELESS, 0, "DŽ", -1, 0, 0, TRUE); TEST_MATCH("[DŽ]", G_REGEX_CASELESS, 0, "DŽ", -1, 0, 0, TRUE);
TEST_MATCH("[DŽ]", G_REGEX_CASELESS, 0, "dž", -1, 0, 0, TRUE); TEST_MATCH("[DŽ]", G_REGEX_CASELESS, 0, "dž", -1, 0, 0, TRUE);
#if PCRE_MAJOR > 8 || (PCRE_MAJOR == 8 && PCRE_MINOR >= 32)
/* This would incorrectly fail to match in pcre < 8.32, so only assert
* this for known-good pcre. */
TEST_MATCH("[DŽ]", G_REGEX_CASELESS, 0, "Dž", -1, 0, 0, TRUE); TEST_MATCH("[DŽ]", G_REGEX_CASELESS, 0, "Dž", -1, 0, 0, TRUE);
#endif
/* TEST_MATCH_NEXT#(pattern, string, string_len, start_position, ...) */ /* TEST_MATCH_NEXT#(pattern, string, string_len, start_position, ...) */
TEST_MATCH_NEXT0("a", "x", -1, 0); TEST_MATCH_NEXT0("a", "x", -1, 0);
TEST_MATCH_NEXT0("a", "ax", -1, 1); TEST_MATCH_NEXT0("a", "ax", -1, 1);
TEST_MATCH_NEXT0("a", "xa", 1, 0); TEST_MATCH_NEXT0("a", "xa", 1, 0);
TEST_MATCH_NEXT0("a", "axa", 1, 2); TEST_MATCH_NEXT0("a", "axa", 1, 2);
TEST_MATCH_NEXT1("", "", -1, 0, "", 0, 0);
TEST_MATCH_NEXT1("a", "a", -1, 0, "a", 0, 1); TEST_MATCH_NEXT1("a", "a", -1, 0, "a", 0, 1);
TEST_MATCH_NEXT1("a", "xax", -1, 0, "a", 1, 2); TEST_MATCH_NEXT1("a", "xax", -1, 0, "a", 1, 2);
TEST_MATCH_NEXT1(EURO, ENG EURO, -1, 0, EURO, 2, 5); TEST_MATCH_NEXT1(EURO, ENG EURO, -1, 0, EURO, 2, 5);
TEST_MATCH_NEXT1("a*", "", -1, 0, "", 0, 0); TEST_MATCH_NEXT1("a*", "", -1, 0, "", 0, 0);
TEST_MATCH_NEXT2("", "a", -1, 0, "", 0, 0, "", 1, 1);
TEST_MATCH_NEXT2("a*", "aa", -1, 0, "aa", 0, 2, "", 2, 2); TEST_MATCH_NEXT2("a*", "aa", -1, 0, "aa", 0, 2, "", 2, 2);
TEST_MATCH_NEXT2(EURO "*", EURO EURO, -1, 0, EURO EURO, 0, 6, "", 6, 6); TEST_MATCH_NEXT2(EURO "*", EURO EURO, -1, 0, EURO EURO, 0, 6, "", 6, 6);
TEST_MATCH_NEXT2("a", "axa", -1, 0, "a", 0, 1, "a", 2, 3); TEST_MATCH_NEXT2("a", "axa", -1, 0, "a", 0, 1, "a", 2, 3);
@ -2677,11 +2673,6 @@ main (int argc, char *argv[])
TEST_EXPAND("a", "a", "\\0130", FALSE, "X"); TEST_EXPAND("a", "a", "\\0130", FALSE, "X");
TEST_EXPAND("a", "a", "\\\\\\0", FALSE, "\\a"); TEST_EXPAND("a", "a", "\\\\\\0", FALSE, "\\a");
TEST_EXPAND("a(?P<G>.)c", "xabcy", "X\\g<G>X", FALSE, "XbX"); TEST_EXPAND("a(?P<G>.)c", "xabcy", "X\\g<G>X", FALSE, "XbX");
#if !(PCRE_MAJOR > 8 || (PCRE_MAJOR == 8 && PCRE_MINOR >= 34))
/* PCRE >= 8.34 no longer allows this usage. */
TEST_EXPAND("(.)(?P<1>.)", "ab", "\\1", FALSE, "a");
TEST_EXPAND("(.)(?P<1>.)", "ab", "\\g<1>", FALSE, "a");
#endif
TEST_EXPAND(".", EURO, "\\0", FALSE, EURO); TEST_EXPAND(".", EURO, "\\0", FALSE, EURO);
TEST_EXPAND("(.)", EURO, "\\1", FALSE, EURO); TEST_EXPAND("(.)", EURO, "\\1", FALSE, EURO);
TEST_EXPAND("(?P<G>.)", EURO, "\\g<G>", FALSE, EURO); TEST_EXPAND("(?P<G>.)", EURO, "\\g<G>", FALSE, EURO);
@ -2800,6 +2791,10 @@ main (int argc, char *argv[])
TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)", "A", 1); TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)", "A", 1);
TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)", "B", 2); TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)", "B", 2);
TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)", "C", -1); TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)", "C", -1);
TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)(?P<C>b)", "A", 1);
TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)(?P<C>b)", "B", 2);
TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)(?P<C>b)", "C", 3);
TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)(?P<C>b)", "D", -1);
TEST_GET_STRING_NUMBER("(?P<A>.)(.)(?P<B>a)", "A", 1); TEST_GET_STRING_NUMBER("(?P<A>.)(.)(?P<B>a)", "A", 1);
TEST_GET_STRING_NUMBER("(?P<A>.)(.)(?P<B>a)", "B", 3); TEST_GET_STRING_NUMBER("(?P<A>.)(.)(?P<B>a)", "B", 3);
TEST_GET_STRING_NUMBER("(?P<A>.)(.)(?P<B>a)", "C", -1); TEST_GET_STRING_NUMBER("(?P<A>.)(.)(?P<B>a)", "C", -1);

41
meson.build
View File

@ -2017,37 +2017,38 @@ else
libiconv = dependency('iconv') libiconv = dependency('iconv')
endif endif
pcre = dependency('libpcre', version: '>= 8.31', required : false) # Should check for Unicode support, too. FIXME pcre2 = dependency('libpcre2-8', version: '>= 10.32', required : false)
if not pcre.found() if not pcre2.found()
if cc.get_id() == 'msvc' or cc.get_id() == 'clang-cl' if cc.get_id() == 'msvc' or cc.get_id() == 'clang-cl'
# MSVC: Search for the PCRE library by the configuration, which corresponds # MSVC: Search for the PCRE2 library by the configuration, which corresponds
# to the output of CMake builds of PCRE. Note that debugoptimized # to the output of CMake builds of PCRE2. Note that debugoptimized
# is really a Release build with .PDB files. # is really a Release build with .PDB files.
if vs_crt == 'debug' if vs_crt == 'debug'
pcre = cc.find_library('pcred', required : false) pcre2 = cc.find_library('pcre2d-8', required : false)
else else
pcre = cc.find_library('pcre', required : false) pcre2 = cc.find_library('pcre2-8', required : false)
endif endif
endif endif
endif endif
# Try again with the fallback # Try again with the fallback
if not pcre.found() if not pcre2.found()
pcre = dependency('libpcre', required : true, fallback : ['pcre', 'pcre_dep']) pcre2 = dependency('libpcre2-8', required : true, fallback : ['pcre2', 'libpcre2_8'])
use_pcre_static_flag = true use_pcre2_static_flag = true
elif host_system == 'windows' elif host_system == 'windows'
pcre_static = cc.links('''#define PCRE_STATIC pcre2_static = cc.links('''#define PCRE2_STATIC
#include <pcre.h> #define PCRE2_CODE_UNIT_WIDTH 8
int main() { #include <pcre2.h>
void *p = NULL; int main() {
pcre_free(p); void *p = NULL;
return 0; pcre2_code_free(p);
}''', return 0;
dependencies: pcre, }''',
name : 'Windows system PCRE is a static build') dependencies: pcre2,
use_pcre_static_flag = pcre_static name : 'Windows system PCRE2 is a static build')
use_pcre2_static_flag = pcre2_static
else else
use_pcre_static_flag = false use_pcre2_static_flag = false
endif endif
# Import the gvdb sources as a subproject to avoid having the copylib in-tree # Import the gvdb sources as a subproject to avoid having the copylib in-tree

2
po/sk.po
View File

@ -5630,7 +5630,7 @@ msgstr "zlý ofset"
msgid "short utf8" msgid "short utf8"
msgstr "krátke utf8" msgstr "krátke utf8"
# Ide o omyl programátora: case PCRE_ERROR_RECURSELOOP: return _("recursion loop"); # Ide o omyl programátora: case PCRE2_ERROR_RECURSELOOP: return _("recursion loop");
#: glib/gregex.c:303 #: glib/gregex.c:303
msgid "recursion loop" msgid "recursion loop"
msgstr "rekurzívna slučka" msgstr "rekurzívna slučka"

11
subprojects/pcre.wrap
View File

@ -1,11 +0,0 @@
[wrap-file]
directory = pcre-8.45
source_url = https://sourceforge.net/projects/pcre/files/pcre/8.45/pcre-8.45.tar.bz2
source_filename = pcre-8.45.tar.bz2
source_hash = 4dae6fdcd2bb0bb6c37b5f97c33c2be954da743985369cddac3546e3218bffb8
patch_filename = pcre_8.45-1_patch.zip
patch_url = https://wrapdb.mesonbuild.com/v2/pcre_8.45-1/get_patch
patch_hash = 821f9b0e5578c5b3983434465de93e30ddfceb92e331a0c9110aba6bf0634ffa
[provide]
libpcre = pcre_dep

9
subprojects/pcre2.wrap
View File

@ -3,14 +3,13 @@ directory = pcre2-10.40
source_url = https://github.com/PhilipHazel/pcre2/releases/download/pcre2-10.40/pcre2-10.40.tar.bz2 source_url = https://github.com/PhilipHazel/pcre2/releases/download/pcre2-10.40/pcre2-10.40.tar.bz2
source_filename = pcre2-10.40.tar.bz2 source_filename = pcre2-10.40.tar.bz2
source_hash = 14e4b83c4783933dc17e964318e6324f7cae1bc75d8f3c79bc6969f00c159d68 source_hash = 14e4b83c4783933dc17e964318e6324f7cae1bc75d8f3c79bc6969f00c159d68
patch_filename = pcre2_10.40-2_patch.zip patch_filename = pcre2_10.40-3_patch.zip
patch_url = https://wrapdb.mesonbuild.com/v2/pcre2_10.40-2/get_patch patch_url = https://wrapdb.mesonbuild.com/v2/pcre2_10.40-3/get_patch
patch_hash = 6c1bbb3c00ec3917b3abee922dedc19ad8b3a199db65ba893a61241e3428bdbd patch_hash = 95391923529b4c1647a2cf88cd3b59cceb4f92393775e011f530e7865de0c7fb
wrapdb_version = 10.40-2 wrapdb_version = 10.40-3
[provide] [provide]
libpcre2-8 = -libpcre2_8 libpcre2-8 = -libpcre2_8
libpcre2-16 = -libpcre2_16 libpcre2-16 = -libpcre2_16
libpcre2-32 = -libpcre2_32 libpcre2-32 = -libpcre2_32
libpcre2-posix = -libpcre2_posix libpcre2-posix = -libpcre2_posix