initial ssed import
Patches applied: * bonzini@gnu.org--2004/sed--stable--4.1--base-0 initial import git-archimport-id: bonzini@gnu.org--2004b/sed--ssed--3.61--patch-1
This commit is contained in:
1 parent
016372d25f
commit
a620e7d5fb
108 files changed
+41109
-19124
No files matched your search
@@ -1,5 +1,6 @@
|
||||
GNU Sed was first authored by Jay Fenlason (hack@gnu.org)
|
||||
and later modified by Tom Lord (lord@gnu.org).
|
||||
GNU Sed, on which super-sed is based, was first authored by
|
||||
Jay Fenlason (hack@gnu.org) and later modified by Tom Lord
|
||||
(lord@gnu.org).
|
||||
|
||||
It is currently being maintained by Ken Pizzini (ken@gnu.org)
|
||||
and Paolo Bonzini (bonzini@gnu.org).
|
||||
@@ -26,6 +26,12 @@ for the bug, but that is not a very practical prospect.
|
||||
|
||||
|
||||
|
||||
* KNOWN BUGS
|
||||
|
||||
The regular expression routines provided must be checked more
|
||||
thoroughly against the POSIX.2 standard.
|
||||
|
||||
|
||||
* NON-BUGS
|
||||
|
||||
`N' command on the last line
|
||||
|
||||
+1
-13
@@ -6,7 +6,7 @@ ACLOCAL_AMFLAGS = -I config
|
||||
|
||||
PACKAGE = sed
|
||||
|
||||
SUBDIRS = intl lib po sed doc testsuite
|
||||
SUBDIRS = intl lib pcre po sed doc testsuite
|
||||
|
||||
noinst_DATA = bootstrap.sh
|
||||
noinst_HEADERS = basicdefs.h
|
||||
@@ -16,15 +16,3 @@ EXTRA_DIST = BUGS THANKS COPYING.DOC README.boot bootstrap.sh \
|
||||
|
||||
html:
|
||||
cd doc && make html
|
||||
|
||||
update-regex:
|
||||
cd lib && \
|
||||
HOST=sources.redhat.com && \
|
||||
BASEURL="http://$$HOST/cgi-bin/cvsweb.cgi/~checkout~/libc/posix" && \
|
||||
QUERY='cvsroot=glibc&content-type=text/plain' && \
|
||||
wget -O regcomp.c "$$BASEURL/regcomp.c?$$QUERY" && \
|
||||
wget -O regexec.c "$$BASEURL/regexec.c?$$QUERY" && \
|
||||
wget -O regex.c "$$BASEURL/regex.c?$$QUERY" && \
|
||||
wget -O regex_.h "$$BASEURL/regex.h?$$QUERY" && \
|
||||
wget -O regex_internal.c "$$BASEURL/regex_internal.c?$$QUERY" && \
|
||||
wget -O regex_internal.h "$$BASEURL/regex_internal.h?$$QUERY"
|
||||
@@ -1,225 +1,182 @@
|
||||
Sed 4.1.3
|
||||
Sed 3.61a
|
||||
|
||||
* added a note to BUGS and the manual about changed interpretation
|
||||
of `s|abc\|def||'.
|
||||
* sed 3.61 had GNU sed 4.1's toplevel Makefile by mistake. Fixed.
|
||||
|
||||
* fixed `make check' in non-English locales.
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
Sed 4.1.2
|
||||
|
||||
* fix bug in 'y' command in multi-byte character sets
|
||||
|
||||
* fix severe bug in parsing of ranges with an embedded open bracket
|
||||
|
||||
* fix off-by-one error when printing a "bad command" error
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
Sed 4.1.1
|
||||
|
||||
* preserve permissions of in-place edited files
|
||||
|
||||
* yield an error when running -i on terminals or other non regular files
|
||||
|
||||
* do not interpret - as stdin when running in in-place editing mode
|
||||
|
||||
* fix bug that prevented 's' command modifiers from working
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
Sed 4.1
|
||||
|
||||
* // matches the last regular expression even in POSIXLY_CORRECT mode.
|
||||
|
||||
* change the way we treat lines which are not terminated by a newline.
|
||||
Such lines are printed without the terminating newline (as before)
|
||||
but as soon as more text is sent to the same output stream, the
|
||||
missing newline is printed, so that the two lines don't concatenate.
|
||||
The behavior is now independent from POSIXLY_CORRECT because POSIX
|
||||
actually has undefined behavior in this case, and the new implementation
|
||||
arguably gives the ``least expected surprise''. Thanks to Stepan
|
||||
Kasal for the implementation.
|
||||
|
||||
* documentation improvements, with updated references to the POSIX.2
|
||||
specification
|
||||
|
||||
* error messages on I/O errors are better, and -i does not leave temporary
|
||||
files around (e.g. when running ``sed -i'' on a directory).
|
||||
|
||||
* escapes are accepted in the y command (for example: y/o/\n/ transforms
|
||||
o's into newlines)
|
||||
|
||||
* -i option tries to set the owner and group to the same as the input file
|
||||
|
||||
* `L' command is deprecated and will be removed in sed 4.2.
|
||||
|
||||
* line number addresses are processed differently -- this is supposedly
|
||||
conformant to POSIX and surely more idiot-proof. Line number addresses
|
||||
are not affected by jumping around them: they are activated and
|
||||
deactivated exactly where the script says, while previously
|
||||
5,8b
|
||||
1,5d
|
||||
would actually delete lines 1,2,3,4 and 9 (!).
|
||||
|
||||
* multibyte characters are taken in consideration to compute the
|
||||
operands of s and y, provided you set LC_CTYPE correctly. They are
|
||||
also considered by \l, \L, \u, \U, \E.
|
||||
|
||||
* [\n] matches either backslash or 'n' when POSIXLY_CORRECT.
|
||||
|
||||
* new option --posix, disables all GNU extensions. POSIXLY_CORRECT only
|
||||
disables GNU extensions that violate the POSIX standard.
|
||||
|
||||
* options -h and -V are not supported anymore, use --help and --version.
|
||||
|
||||
* removed documentation for \s and \S which worked incorrectly
|
||||
|
||||
* restored correct behavior for \w and \W: match [[:alnum:]_] and
|
||||
[^[:alnum:]_] (they used to match [[:alpha:]_] and [^[:alpha:]_]
|
||||
|
||||
* the special address 0 can only be used in 0,/RE/ or 0~STEP addresses;
|
||||
other cases give an error (you are hindering portability for no reason
|
||||
if specifying 0,N and you are giving a dead command if specifying 0
|
||||
alone).
|
||||
|
||||
* when a \ is used to escape the character that would terminate an operand
|
||||
of the s or y commands, the backslash is removed before the regex is
|
||||
compiled. This is left undefined by POSIX; this behavior makes `s+x\+++g'
|
||||
remove occurrences of `x+', consistently with `s/x\///g'. (However, if
|
||||
you enjoy yourself trying `s*x\***g', sed will use the `x*' regex, and you
|
||||
won't be able to pass down `x\*' while using * as the delimiter; ideas on
|
||||
how to simplify the parser in this respect, and/or gain more coherent
|
||||
semantics, are welcome).
|
||||
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
Sed 4.0.9
|
||||
-----------------------------------------------------------------------
|
||||
Sed 3.61 (aligned with GNU sed 4.1)
|
||||
|
||||
* 0 address behaves correctly in single-file (-i and -s) mode.
|
||||
|
||||
* documentation improvements.
|
||||
|
||||
* tested with many hosts and compilers.
|
||||
|
||||
* updated regex matcher from upstream, with many bugfixes and speedups.
|
||||
|
||||
* the `N' command's feature that is detailed in the BUGS file was disabled
|
||||
by the first change below in sed 4.0.8. The behavior has now been
|
||||
restored, and is only enabled if POSIXLY_CORRECT behavior is not
|
||||
requested.
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
Sed 4.0.8
|
||||
|
||||
* fix `sed n' printing the last line twice.
|
||||
|
||||
* fix incorrect error message for invalid character classes.
|
||||
|
||||
* fix segmentation violation with repeated empty subexpressions.
|
||||
|
||||
* fix incorrect parsing of ^ after escaped (.
|
||||
|
||||
* more comprehensive test suite (and with many expected failures...)
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
Sed 4.0.7
|
||||
|
||||
* VPATH builds working on non-glibc machines
|
||||
|
||||
* fixed bug in s///Np: was printing even if less than N matches were
|
||||
found.
|
||||
|
||||
* fixed infinite loop on s///N when LHS matched a null string and
|
||||
there were not enough matches in pattern space
|
||||
|
||||
* behavior of s///N is consistent with s///g when the LHS can match
|
||||
a null string (and the infinite loop did not happen :-)
|
||||
|
||||
* updated some translations
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
Sed 4.0.6
|
||||
* // matches the last regular expression even in POSIXLY_CORRECT mode.
|
||||
|
||||
* added parameter to `v' for the version of sed that is expected.
|
||||
Also, `v' disables POSIXLY_CORRECT behavior.
|
||||
|
||||
* configure switch --without-included-regex to use the system regex matcher
|
||||
* change the way we treat lines which are not terminated by a newline.
|
||||
Such lines are printed without the terminating newline (as before)
|
||||
but as soon as more text is sent to the same output stream, the
|
||||
missing newline is printed, so that the two lines don't concatenate.
|
||||
The behavior is now independent from POSIXLY_CORRECT because POSIX
|
||||
actually has undefined behavior in this case, and the new implementation
|
||||
arguably gives the ``least expected surprise''. Thanks to Stepan
|
||||
Kasal for discussing the issue and providing the implementation.
|
||||
|
||||
* fix for -i option under Cygwin
|
||||
* documentation improvements, with updated references to the POSIX.2
|
||||
specification
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
Sed 4.0.5
|
||||
* error messages on I/O errors are better, and -i does not leave temporary
|
||||
files around (e.g. when running ``sed -i'' on a directory).
|
||||
|
||||
* portability fixes
|
||||
* escapes are accepted in the y command (for example: y/o/\n/ transforms
|
||||
o's into newlines)
|
||||
|
||||
* fix for -i under Cygwin; also, the -i option tries to set the owner
|
||||
and group to the same as the input file
|
||||
|
||||
* improvements to some error messages (e.g. y/abc/defg/ incorrectly said
|
||||
`excess characters after command' instead of `y arguments have different
|
||||
lengths')
|
||||
`excess characters after command' instead of `y arguments have
|
||||
different lengths')
|
||||
|
||||
* `a', `i', `l', `L', `r' accept two addresses except in POSIXLY_CORRECT
|
||||
mode. Only `q' and `Q' do not accept two addresses in standard (GNU) mode.
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
Sed 4.0.4
|
||||
|
||||
* documentation fixes
|
||||
|
||||
* update regex matcher
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
Sed 4.0.3
|
||||
|
||||
* fix packaging problem (two missing translation catalogs)
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
Sed 4.0.2
|
||||
* line number addresses are processed differently -- this is supposedly
|
||||
conformant to POSIX and surely more idiot-proof. Line number addresses
|
||||
are not affected by jumping around them: they are activated and
|
||||
deactivated exactly where the script says, while previously
|
||||
5,8b
|
||||
1,5d
|
||||
would actually delete lines 1,2,3,4 and 9 (!).
|
||||
|
||||
* more translations
|
||||
|
||||
* fix build problems (vpath builds and bootstrap builds)
|
||||
* multibyte characters are taken in consideration to compute the
|
||||
operands of s and y, provided you set LC_CTYPE correctly. However,
|
||||
the regular expression matcher does not support them yet.
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
Sed 4.0.1
|
||||
* new option --posix, disables all extensions. POSIXLY_CORRECT only
|
||||
disables extensions that violate the POSIX standard.
|
||||
|
||||
* Remove last vestiges of super-sed
|
||||
* options -h and -V are not supported anymore, use --help and --version.
|
||||
|
||||
* man page automatically built
|
||||
* Perl's \G escape is supported both in Perl and POSIX regexps (not in
|
||||
GNU sed).
|
||||
|
||||
* more translations provided
|
||||
* portability fixes
|
||||
|
||||
* portability improvements
|
||||
* support for [[:blank:]] character class
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
Sed 4.0
|
||||
* the -i option tries to set the owner and group to the same as the input
|
||||
file
|
||||
|
||||
* Update regex matcher
|
||||
* the `L' command is deprecated and will be removed as soon as GNU sed
|
||||
removes it.
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
Sed 3.96
|
||||
* the `N' command's feature that is detailed in the BUGS file is disabled
|
||||
if POSIXLY_CORRECT behavior is requested.
|
||||
|
||||
* `y' command supports multibyte character sets
|
||||
* the special address 0 can only be used in 0,/RE/ or 0~STEP addresses;
|
||||
other cases give an error (you are hindering portability for no reason
|
||||
if specifying 0,N and you are giving a dead command if specifying 0
|
||||
alone).
|
||||
|
||||
* Update regex matcher
|
||||
* `a', `i', `l', `L', `r' accept two addresses except in POSIXLY_CORRECT
|
||||
mode. Only `q' and `Q' do not accept two addresses in standard mode.
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
Sed 3.95
|
||||
* when a \ is used to escape the character that would terminate an operand
|
||||
of the s or y commands, the character loses any meaning as a metacharacter.
|
||||
This is left undefined by POSIX; this behavior makes `s+x\+++g' remove
|
||||
occurrences of `x+', consistently with `s/x\///g'.
|
||||
|
||||
-----------------------------------------------------------------------
|
||||
Sed 3.60 (aligned with GNU sed 4.0)
|
||||
|
||||
* Maintainance release with no visible changes except more translations
|
||||
were added. Limits differences in source code between GNU sed 4.x
|
||||
and ssed.
|
||||
|
||||
-----------------------------------------------------------------------
|
||||
Sed 3.59
|
||||
|
||||
* `R' command reads a single line from a file.
|
||||
|
||||
* CR-LF pairs are always ignored under Windows, even if (under Cygwin)
|
||||
a disk is mounted as binary.
|
||||
a disk is mounted as binary.
|
||||
|
||||
* Fixed bug in the numeric parameter to `s'. The replacement flag
|
||||
was set on the first match of the regular expression, not on the Nth.
|
||||
|
||||
* Fixed bug in /.{1,64}/
|
||||
|
||||
* More attention to errors on stdout
|
||||
|
||||
* New `W' command to write first line of pattern space to a file
|
||||
|
||||
-----------------------------------------------------------------------
|
||||
Sed 3.58
|
||||
|
||||
* Can customize line wrap width on single `l' commands
|
||||
|
||||
* `L' command formats and reflows paragraphs like `fmt' does.
|
||||
|
||||
* Upgraded to autoconf 2.53
|
||||
|
||||
* When running a script with in-place editing, command ranges such as
|
||||
/abc/,/def/, line numbers, and the special $ address are reset for
|
||||
each file. The same can be done with the new `-s' option when in-
|
||||
place editing is off.
|
||||
|
||||
-----------------------------------------------------------------------
|
||||
Sed 3.57
|
||||
|
||||
* Fixed problems with `-i' when /tmp was on a different volume
|
||||
|
||||
* Fixed problems in \[lLuUE] (due to a construct with undefined
|
||||
behavior which some newer compilers optimized away)
|
||||
|
||||
-----------------------------------------------------------------------
|
||||
Sed 3.56
|
||||
|
||||
* Added another "heavy-weight" test (like dc.sed) to the testsuite.
|
||||
|
||||
* Bug fix: after using the D command, the first line could have been
|
||||
considered valid by a subsequent [GH] command.
|
||||
|
||||
* Prune impossible backtracking paths (e.g. b*c does not backtrack
|
||||
on b).
|
||||
|
||||
* The test suite makefiles are better organized (this change is
|
||||
transparent however).
|
||||
|
||||
-----------------------------------------------------------------------
|
||||
Sed 3.55
|
||||
|
||||
* Bug fix: Inside a character class, an unrecognized escape sequence
|
||||
is interpreted as two separate characters: for example [\g] is a
|
||||
character class made of a backslash and a `g'. I thought I had
|
||||
fixed this in 3.49, but that fix was not enough.
|
||||
|
||||
-----------------------------------------------------------------------
|
||||
Sed 3.54
|
||||
|
||||
* Bug fix: s/^xxxxx//p did not print (related to the optimization
|
||||
introduced by Sed 3.53). This broke Automake 1.5's dependency
|
||||
tracking, so if you installed Sed 3.53 as the system sed you should
|
||||
configure with --disable-dependency-tracking.
|
||||
|
||||
-----------------------------------------------------------------------
|
||||
Sed 3.53
|
||||
|
||||
* Bug fix: The meanings \` and \' were swapped.
|
||||
|
||||
* Compiles and bootstraps out-of-the-box under MinGW32 and Cygwin.
|
||||
|
||||
* Faster on most regular expression because it uses the Boyer-Moore
|
||||
algorithm to process initial fixed-length strings. The "set of
|
||||
possible first characters" algorithm is used as a fallback there
|
||||
is no such string (e.g. when a regex starts with a star or question
|
||||
mark pattern: [0-9]*).
|
||||
|
||||
* Has a comprehensive test suite for both Posix and PERL regular
|
||||
expressions.
|
||||
|
||||
* Optimizes cases when pattern space is truncated at its start or at
|
||||
its end by `D' or by a substitution command with an empty RHS.
|
||||
For example scripts like this,
|
||||
@@ -229,15 +186,53 @@ For example scripts like this,
|
||||
whose behavior was quadratic with previous versions of sed, have
|
||||
now linear behavior.
|
||||
|
||||
------------------------------------------------------------------------
|
||||
Sed 3.52
|
||||
|
||||
* Merged with PCRE 3.7:
|
||||
|
||||
** pcre_exec() was referring to its "code" argument before testing
|
||||
that argument for NULL (and giving an error if it was NULL).
|
||||
|
||||
** The limit of 200 on non-capturing parentheses is a _nesting_ limit,
|
||||
not an absolute limit. Changed the text of the error message to make
|
||||
this clear, and likewise updated the man page.
|
||||
|
||||
** The limit of 99 on the number of capturing subpatterns has been
|
||||
removed.
|
||||
|
||||
* New command `e' to pipe the output of a command into the output
|
||||
of sed.
|
||||
|
||||
* New option `e' to pass the output of the `s' command through the
|
||||
Bourne shell and get the result into pattern space.
|
||||
|
||||
* Simple minded optimization in the matcher: if the regexp is
|
||||
anchored to the end of the pattern, and the regexp cannot match
|
||||
more than some number of characters, leap to the end of pattern
|
||||
space minus that number of characters. For example, abc[def]$
|
||||
will start matching four characters before the end of pattern
|
||||
space.
|
||||
|
||||
* Switched to obstacks in the parser -- less memory-related bugs
|
||||
(there were none AFAIK but you never know) and less memory usage.
|
||||
|
||||
------------------------------------------------------------------------
|
||||
Sed 3.51
|
||||
|
||||
* Bug fix: behavior of undefined regular expressions (such as a single
|
||||
star `*') is more consistent with GNU sed and does not issue
|
||||
internal errors anymore.
|
||||
|
||||
* Bug fix: fixed internal error when backslashed expressions appeared
|
||||
inside character classes (e.g. [\X]). This broke autoconf 2.50 or
|
||||
later.
|
||||
|
||||
------------------------------------------------------------------------
|
||||
Sed 3.50
|
||||
|
||||
* Updated to latest autoconf and automake.
|
||||
|
||||
* New option -i, to support in-place editing a la Perl. Usually one
|
||||
had to use ed or, for more complex tasks, resort to Perl; this is
|
||||
not necessary anymore.
|
||||
@@ -249,23 +244,59 @@ not definitive, though.
|
||||
* Bug fix: Made the behavior of s/A*/x/g (i.e. `s' command with a
|
||||
possibly empty LHS) more consistent:
|
||||
|
||||
pattern GNU sed 3.x GNU sed 4.x
|
||||
pattern 3.49 or GNU sed 3.50
|
||||
B xBx xBx
|
||||
BC xBxCx xBxCx
|
||||
BAC xBxxCx xBxCx
|
||||
BAAC xBxxCx xBxCx
|
||||
|
||||
Earlier versions matched a spurious empty string after the sequence
|
||||
of A's.
|
||||
|
||||
------------------------------------------------------------------------
|
||||
Sed 3.49
|
||||
|
||||
* Bug fix: Inside a character class, an unrecognized escape sequence
|
||||
is interpreted as two separate characters: for example [\g] is a
|
||||
character class made of a backslash and a `g'. This change is
|
||||
needed for compatibility with autoconf 2.50.
|
||||
|
||||
------------------------------------------------------------------------
|
||||
Sed 3.48
|
||||
|
||||
* Bug fix: on the RHS of the `s' command, the syntax of the octal
|
||||
constants is the same as for Perl. Note that it is not possible
|
||||
yet to specify more than 9 backreferences on the RHS of the `s'
|
||||
command.
|
||||
|
||||
* Bug fix: \c is parsed on the RHS of the `s' command.
|
||||
|
||||
* Bug fix: the q and Q commands could be misinterpreted, leading to
|
||||
spurious syntax errors in the following command
|
||||
|
||||
* Bug fix: the // empty regular expressions now refers to the last
|
||||
regular expression that was matched, rather than to the last
|
||||
regular expression that was compiled. This richer behavior seems
|
||||
to be the correct one (albeit neither one is POSIXLY_CORRECT).
|
||||
|
||||
* Check for invalid backreferences in the RHS of the `s' command
|
||||
(e.g. s/1234/\1/)
|
||||
------------------------------------------------------------------------
|
||||
Sed 3.47
|
||||
|
||||
* Support for \[lLuUE] in the RHS of the `s' command like in Perl.
|
||||
* This version adds a check for invalid backreferences in the
|
||||
RHS of the `s' command (e.g. s/1234/\1/) and support for
|
||||
\[lLuUE] in the RHS of the `s' command like in Perl.
|
||||
|
||||
* New regular expression matcher
|
||||
------------------------------------------------------------------------
|
||||
Sed 3.46
|
||||
|
||||
* This version is not an official GNU release, hence it is dubbed
|
||||
`super-sed' and uses a strange version number unlikely to clash
|
||||
with GNU sed's numbering. It is my hope to merge super-sed's
|
||||
changes with GNU sed one day, but at the moment they should be
|
||||
considered separate programs at all effects.
|
||||
|
||||
* It uses a different regular expression matcher which is much more
|
||||
faster (6x to 20x), especially on backreferences.
|
||||
|
||||
* Bug fix: if a file was redirected to be stdin, sed did not consume
|
||||
it. So
|
||||
@@ -277,19 +308,24 @@ double-spaced TESTFILE, while the equivalent `useless use of cat'
|
||||
printed nothing (which is the correct behavior). A test for this
|
||||
bug was added to the test suite.
|
||||
|
||||
* A bug in the test suite (the khadafy test was run with BREs instead
|
||||
of EREs) has been corrected.
|
||||
|
||||
* The documentation is now much better, with a few examples provided,
|
||||
and a thorough description of regular expressions. The manual often
|
||||
refers to "GNU extensions", but if they are described here they are
|
||||
specific to this version.
|
||||
|
||||
* Documented command-line option:
|
||||
* Added new command-line options:
|
||||
-r, --regexp-extended
|
||||
Use extended regexps -- e.g. (abc+) instead of \(abc\+\)
|
||||
-R, --regexp-perl
|
||||
Use Perl regexps (\l, \L, \u, \U, \E not supported)
|
||||
|
||||
* Added feature to the `w' command and to the `w' option of the `s'
|
||||
command: if the file name is /dev/stderr, it means the standard
|
||||
error (inspired by awk); and similarly for /dev/stdout. This is
|
||||
disabled if POSIXLY_CORRECT is set.
|
||||
error (inspired by awk). This is disabled if POSIXLY_CORRECT is
|
||||
set.
|
||||
|
||||
* Added `m' and `M' modifiers to `s' command for multi-line
|
||||
matching (Perl-style); in addresses, only `M' works.
|
||||
@@ -300,7 +336,9 @@ an exit code from a sed script to the caller.
|
||||
* Added `T' command for `branch if failed'.
|
||||
|
||||
* Added `v' command, which is a do-nothing intended to fail on
|
||||
seds that do not support GNU sed 4.0's extensions.
|
||||
seds that do not support super-sed's extensions.
|
||||
|
||||
* Bootstrapping was tested and is known to work.
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
Sed 3.02.80
|
||||
|
||||
@@ -1,7 +1,9 @@
|
||||
This is the GNU implementation of sed, the Unix stream editor.
|
||||
This is a version of sed based on GNU sed. It is not
|
||||
a version of GNU sed, though.
|
||||
|
||||
See the NEWS file for a brief summary and the ChangeLog for
|
||||
more detailed descriptions of changes.
|
||||
There are several new features, including extended regular expression
|
||||
syntax, and some bug fixes; see the NEWS file for a brief summary
|
||||
and the ChangeLog for more detailed descriptions of changes.
|
||||
|
||||
See the file INSTALL for generic compilation and installation
|
||||
instructions.
|
||||
|
||||
@@ -71,6 +71,16 @@ ${CC} -DHAVE_CONFIG_H -I.. -I. -c regex.c || exit 1
|
||||
${CC} -DHAVE_CONFIG_H -I.. -I. -c strerror.c || exit 1
|
||||
${CC} -DHAVE_CONFIG_H -I.. -I. -c utils.c || exit 1
|
||||
|
||||
cd ../pcre || exit 1
|
||||
${CC} -DHAVE_CONFIG_H -I.. -I. -I../lib -c regdebug.c || exit 1
|
||||
${CC} -DHAVE_CONFIG_H -I.. -I. -I../lib -c regexp.c || exit 1
|
||||
${CC} -DHAVE_CONFIG_H -I.. -I. -I../lib -c reginfo.c || exit 1
|
||||
${CC} -DHAVE_CONFIG_H -I.. -I. -I../lib -c regperl.c || exit 1
|
||||
${CC} -DHAVE_CONFIG_H -I.. -I. -I../lib -c regposix.c || exit 1
|
||||
${CC} -DHAVE_CONFIG_H -I.. -I. -I../lib -c regstudy.c || exit 1
|
||||
${CC} -DHAVE_CONFIG_H -I.. -I. -I../lib -c regsub.c || exit 1
|
||||
${CC} -DHAVE_CONFIG_H -I.. -I. -I../lib -c regtables.c || exit 1
|
||||
|
||||
cd ../sed || exit 1
|
||||
${CC} -DHAVE_CONFIG_H -I.. -I. -I../lib -c sed.c || exit 1
|
||||
${CC} -DHAVE_CONFIG_H -I.. -I. -I../lib -c fmt.c || exit 1
|
||||
|
||||
+8
-30
@@ -1,5 +1,5 @@
|
||||
dnl Process this file with -*- autoconf -*- to produce a configure script.
|
||||
AC_INIT(sed, 4.1.2, bonzini@gnu.org, sed)
|
||||
AC_INIT(sed, 3.61, bonzini@gnu.org, ssed)
|
||||
AC_CONFIG_AUX_DIR(config)
|
||||
AC_CONFIG_SRCDIR([sed/sed.c])
|
||||
AM_CONFIG_HEADER(config.h:config_h.in)
|
||||
@@ -66,37 +66,15 @@ AC_FUNC_OBSTACK
|
||||
AC_FUNC_MBRTOWC
|
||||
AC_TYPE_MBSTATE_T
|
||||
gl_FUNC_STRVERSCMP
|
||||
AC_REPLACE_FUNCS(memchr memcmp memmove strerror mkstemp)
|
||||
AC_REPLACE_FUNCS(memchr memcmp memmove strerror snprintf mkstemp)
|
||||
AC_CHECK_FUNCS(isatty bcopy bzero isascii memcpy memset strchr strtoul popen \
|
||||
pathconf isblank fchown fchmod setlocale wcrtomb wcscoll btowc)
|
||||
|
||||
AC_ARG_WITH(included-regex,
|
||||
[ --with-included-regex use included regex matcher (default=yes)], ,
|
||||
with_included_regex=yes)
|
||||
|
||||
AC_ARG_ENABLE(regex-tests,
|
||||
[ --enable-regex-tests enable regex matcher regression tests (default=no)], ,
|
||||
enable_regex_tests=no)
|
||||
|
||||
if test "x$with_included_regex" = xno; then
|
||||
AC_CHECK_HEADERS(regex.h)
|
||||
AC_CHECK_LIB(regex, re_search)
|
||||
AC_CHECK_FUNC(re_search)
|
||||
if test $ac_cv_header_regex_h = no || test $ac_cv_func_re_search = no; then
|
||||
AC_MSG_WARN([GNU regex not found, falling back to the included version])
|
||||
with_included_regex=yes
|
||||
fi
|
||||
fi
|
||||
|
||||
if test "x$with_included_regex" = xno; then
|
||||
enable_regex_tests=no
|
||||
fi
|
||||
|
||||
AM_CONDITIONAL(TEST_REGEX, test "x$enable_regex_tests" != xno)
|
||||
if test "x$with_included_regex" != xno; then
|
||||
AC_CONFIG_LINKS(lib/regex.h:lib/regex_.h)
|
||||
AC_LIBOBJ(regex)
|
||||
fi
|
||||
AC_ARG_ENABLE(pcregrep,
|
||||
[ --enable-pcregrep build the pcregrep test program],
|
||||
PCREGREP=pcregrep,
|
||||
PCREGREP=)
|
||||
AC_SUBST(PCREGREP)
|
||||
|
||||
AC_ARG_ENABLE(html,
|
||||
[ --enable-html build HTML manual (default=no)], ,
|
||||
@@ -135,5 +113,5 @@ AM_GNU_GETTEXT(, need-ngettext)
|
||||
AC_CONFIG_FILES([bootstrap.sh], chmod +x bootstrap.sh)
|
||||
AC_CONFIG_FILES([Makefile doc/Makefile \
|
||||
lib/Makefile sed/Makefile testsuite/Makefile \
|
||||
po/Makefile.in intl/Makefile])
|
||||
po/Makefile.in intl/Makefile pcre/Makefile])
|
||||
AC_OUTPUT
|
||||
+1
-1
@@ -2,7 +2,7 @@
|
||||
info_TEXINFOS = sed.texi
|
||||
sed_TEXINFOS = config.texi version.texi
|
||||
dist_man_MANS = sed.1
|
||||
dist_noinst_DATA = sed.x sed-in.texi
|
||||
dist_noinst_DATA = sed.x sed-in.texi pcre.html
|
||||
dist_noinst_SCRIPTS = groupify.sed
|
||||
CLEANFILES = sed.html
|
||||
TEXI2DVI = $(top_srcdir)/config/texi2dvi --expand
|
||||
|
||||
+3
-3
@@ -4,6 +4,6 @@
|
||||
|
||||
@end direntry
|
||||
|
||||
@clear PERL
|
||||
@set SSEDEXT @acronym{GNU} extensions
|
||||
@set SSED @acronym{GNU} @command{sed}
|
||||
@set PERL
|
||||
@set SSEDEXT @acronym{ssed} extensions
|
||||
@set SSED @command{super-sed}
|
||||
+801
@@ -0,0 +1,801 @@
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<TITLE>pcre specification</TITLE>
|
||||
</HEAD>
|
||||
<body bgcolor="#FFFFFF" text="#00005A">
|
||||
<H1>pcre specification</H1>
|
||||
<UL>
|
||||
<LI><A NAME="TOC1" HREF="#SEC1">NAME</A>
|
||||
<LI><A NAME="TOC2" HREF="#SEC2">SYNOPSIS</A>
|
||||
<LI><A NAME="TOC3" HREF="#SEC3">DESCRIPTION</A>
|
||||
<LI><A NAME="TOC4" HREF="#SEC4">MULTI-THREADING</A>
|
||||
<LI><A NAME="TOC5" HREF="#SEC5">COMPILING A PATTERN</A>
|
||||
<LI><A NAME="TOC6" HREF="#SEC6">STUDYING A PATTERN</A>
|
||||
<LI><A NAME="TOC7" HREF="#SEC7">LOCALE SUPPORT</A>
|
||||
<LI><A NAME="TOC8" HREF="#SEC8">INFORMATION ABOUT A PATTERN</A>
|
||||
<LI><A NAME="TOC9" HREF="#SEC9">MATCHING A PATTERN</A>
|
||||
<LI><A NAME="TOC10" HREF="#SEC10">EXTRACTING CAPTURED SUBSTRINGS</A>
|
||||
<LI><A NAME="TOC11" HREF="#SEC11">AUTHOR</A>
|
||||
</UL>
|
||||
<LI><A NAME="SEC1" HREF="#TOC1">NAME</A>
|
||||
<P>
|
||||
pcre - Perl-compatible regular expressions.
|
||||
</P>
|
||||
<LI><A NAME="SEC2" HREF="#TOC1">SYNOPSIS</A>
|
||||
<P>
|
||||
<B>#include <pcre.h></B>
|
||||
</P>
|
||||
<P>
|
||||
<B>pcre *pcre_compile(const char *<I>pattern</I>, int <I>options</I>,</B>
|
||||
<B>const char **<I>errptr</I>, int *<I>erroffset</I>,</B>
|
||||
<B>const unsigned char *<I>tableptr</I>);</B>
|
||||
</P>
|
||||
<P>
|
||||
<B>pcre_extra *pcre_study(const pcre *<I>code</I>, int <I>options</I>,</B>
|
||||
<B>const char **<I>errptr</I>);</B>
|
||||
</P>
|
||||
<P>
|
||||
<B>int pcre_exec(const pcre *<I>code</I>, const pcre_extra *<I>extra</I>,</B>
|
||||
<B>const char *<I>subject</I>, int <I>length</I>, int <I>startoffset</I>,</B>
|
||||
<B>int <I>options</I>, int *<I>ovector</I>, int <I>ovecsize</I>);</B>
|
||||
</P>
|
||||
<P>
|
||||
<B>int pcre_copy_substring(const char *<I>subject</I>, int *<I>ovector</I>,</B>
|
||||
<B>int <I>stringcount</I>, int <I>stringnumber</I>, char *<I>buffer</I>,</B>
|
||||
<B>int <I>buffersize</I>);</B>
|
||||
</P>
|
||||
<P>
|
||||
<B>int pcre_get_substring(const char *<I>subject</I>, int *<I>ovector</I>,</B>
|
||||
<B>int <I>stringcount</I>, int <I>stringnumber</I>,</B>
|
||||
<B>const char **<I>stringptr</I>);</B>
|
||||
</P>
|
||||
<P>
|
||||
<B>int pcre_get_substring_list(const char *<I>subject</I>,</B>
|
||||
<B>int *<I>ovector</I>, int <I>stringcount</I>, const char ***<I>listptr</I>);</B>
|
||||
</P>
|
||||
<P>
|
||||
<B>void pcre_free_substring(const char *<I>stringptr</I>);</B>
|
||||
</P>
|
||||
<P>
|
||||
<B>void pcre_free_substring_list(const char **<I>stringptr</I>);</B>
|
||||
</P>
|
||||
<P>
|
||||
<B>const unsigned char *pcre_maketables(void);</B>
|
||||
</P>
|
||||
<P>
|
||||
<B>int pcre_info(const pcre *<I>code</I>, const pcre_extra *<I>extra</I>,</B>
|
||||
<B>int <I>what</I>, void *<I>where</I>);</B>
|
||||
</P>
|
||||
<P>
|
||||
<B>void *(*pcre_malloc)(size_t);</B>
|
||||
</P>
|
||||
<P>
|
||||
<B>void (*pcre_free)(void *);</B>
|
||||
</P>
|
||||
<LI><A NAME="SEC3" HREF="#TOC1">DESCRIPTION</A>
|
||||
<P>
|
||||
The PCRE library is a set of functions that implement regular expression
|
||||
pattern matching using the same syntax and semantics as Perl 5, with just a few
|
||||
differences (see below). The current implementation corresponds to Perl 5.005,
|
||||
with some additional features from later versions. This includes some
|
||||
experimental, incomplete support for UTF-8 encoded strings. Details of exactly
|
||||
what is and what is not supported are given below.
|
||||
</P>
|
||||
<P>
|
||||
PCRE has its own native API, which is described in this document. There is also
|
||||
a set of wrapper functions that correspond to the POSIX regular expression API.
|
||||
These are described in the <B>pcreposix</B> documentation.
|
||||
</P>
|
||||
<P>
|
||||
The native API function prototypes are defined in the header file <B>pcre.h</B>,
|
||||
and on Unix systems the library itself is called <B>libpcre.a</B>, so can be
|
||||
accessed by adding <B>-lpcre</B> to the command for linking an application which
|
||||
calls it. The header file defines the macros PCRE_MAJOR and PCRE_MINOR to
|
||||
contain the major and minor release numbers for the library. Applications can
|
||||
use these to include support for different releases.
|
||||
</P>
|
||||
<P>
|
||||
The functions <B>pcre_compile()</B>, <B>pcre_study()</B>, and <B>pcre_exec()</B>
|
||||
are used for compiling and matching regular expressions.
|
||||
</P>
|
||||
<P>
|
||||
The functions <B>pcre_copy_substring()</B>, <B>pcre_get_substring()</B>, and
|
||||
<B>pcre_get_substring_list()</B> are convenience functions for extracting
|
||||
captured substrings from a matched subject string; <B>pcre_free_substring()</B>
|
||||
and <B>pcre_free_substring_list()</B> are also provided, to free the memory used
|
||||
for extracted strings.
|
||||
</P>
|
||||
<P>
|
||||
The function <B>pcre_maketables()</B> is used (optionally) to build a set of
|
||||
character tables in the current locale for passing to <B>pcre_compile()</B>.
|
||||
</P>
|
||||
<P>
|
||||
The function <B>pcre_info()</B> is used to find out information about a
|
||||
compiled pattern.
|
||||
</P>
|
||||
<P>
|
||||
The global variables <B>pcre_malloc</B> and <B>pcre_free</B> initially contain
|
||||
the entry points of the standard <B>malloc()</B> and <B>free()</B> functions
|
||||
respectively. PCRE calls the memory management functions via these variables,
|
||||
so a calling program can replace them if it wishes to intercept the calls. This
|
||||
should be done before calling any PCRE functions.
|
||||
</P>
|
||||
<LI><A NAME="SEC4" HREF="#TOC1">MULTI-THREADING</A>
|
||||
<P>
|
||||
The PCRE functions can be used in multi-threading applications, with the
|
||||
proviso that the memory management functions pointed to by <B>pcre_malloc</B>
|
||||
and <B>pcre_free</B> are shared by all threads.
|
||||
</P>
|
||||
<P>
|
||||
The compiled form of a regular expression is not altered during matching, so
|
||||
the same compiled pattern can safely be used by several threads at once.
|
||||
</P>
|
||||
<LI><A NAME="SEC5" HREF="#TOC1">COMPILING A PATTERN</A>
|
||||
<P>
|
||||
The function <B>pcre_compile()</B> is called to compile a pattern into an
|
||||
internal form. The pattern is a C string terminated by a binary zero, and
|
||||
is passed in the argument <I>pattern</I>. A pointer to a single block of memory
|
||||
that is obtained via <B>pcre_malloc</B> is returned. This contains the
|
||||
compiled code and related data. The <B>pcre</B> type is defined for this for
|
||||
convenience, but in fact <B>pcre</B> is just a typedef for <B>void</B>, since the
|
||||
contents of the block are not externally defined. It is up to the caller to
|
||||
free the memory when it is no longer required.
|
||||
</P>
|
||||
<P>
|
||||
The size of a compiled pattern is roughly proportional to the length of the
|
||||
pattern string, except that each character class (other than those containing
|
||||
just a single character, negated or not) requires 33 bytes, and repeat
|
||||
quantifiers with a minimum greater than one or a bounded maximum cause the
|
||||
relevant portions of the compiled pattern to be replicated.
|
||||
</P>
|
||||
<P>
|
||||
The <I>options</I> argument contains independent bits that affect the
|
||||
compilation. It should be zero if no options are required. Some of the options,
|
||||
in particular, those that are compatible with Perl, can also be set and unset
|
||||
from within the pattern (see the detailed description of regular expressions
|
||||
below). For these options, the contents of the <I>options</I> argument specifies
|
||||
their initial settings at the start of compilation and execution. The
|
||||
PCRE_ANCHORED option can be set at the time of matching as well as at compile
|
||||
time.
|
||||
</P>
|
||||
<P>
|
||||
If <I>errptr</I> is NULL, <B>pcre_compile()</B> returns NULL immediately.
|
||||
Otherwise, if compilation of a pattern fails, <B>pcre_compile()</B> returns
|
||||
NULL, and sets the variable pointed to by <I>errptr</I> to point to a textual
|
||||
error message. The offset from the start of the pattern to the character where
|
||||
the error was discovered is placed in the variable pointed to by
|
||||
<I>erroffset</I>, which must not be NULL. If it is, an immediate error is given.
|
||||
</P>
|
||||
<P>
|
||||
If the final argument, <I>tableptr</I>, is NULL, PCRE uses a default set of
|
||||
character tables which are built when it is compiled, using the default C
|
||||
locale. Otherwise, <I>tableptr</I> must be the result of a call to
|
||||
<B>pcre_maketables()</B>. See the section on locale support below.
|
||||
</P>
|
||||
<P>
|
||||
The following option bits are defined in the header file:
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_ANCHORED
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
If this bit is set, the pattern is forced to be "anchored", that is, it is
|
||||
constrained to match only at the start of the string which is being searched
|
||||
(the "subject string"). This effect can also be achieved by appropriate
|
||||
constructs in the pattern itself, which is the only way to do it in Perl.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_CASELESS
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
If this bit is set, letters in the pattern match both upper and lower case
|
||||
letters. It is equivalent to Perl's /i option.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_DOLLAR_ENDONLY
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
If this bit is set, a dollar metacharacter in the pattern matches only at the
|
||||
end of the subject string. Without this option, a dollar also matches
|
||||
immediately before the final character if it is a newline (but not before any
|
||||
other newlines). The PCRE_DOLLAR_ENDONLY option is ignored if PCRE_MULTILINE is
|
||||
set. There is no equivalent to this option in Perl.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_DOTALL
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
If this bit is set, a dot metacharater in the pattern matches all characters,
|
||||
including newlines. Without it, newlines are excluded. This option is
|
||||
equivalent to Perl's /s option. A negative class such as [^a] always matches a
|
||||
newline character, independent of the setting of this option.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_EXTENDED
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
If this bit is set, whitespace data characters in the pattern are totally
|
||||
ignored except when escaped or inside a character class, and characters between
|
||||
an unescaped # outside a character class and the next newline character,
|
||||
inclusive, are also ignored. This is equivalent to Perl's /x option, and makes
|
||||
it possible to include comments inside complicated patterns. Note, however,
|
||||
that this applies only to data characters. Whitespace characters may never
|
||||
appear within special character sequences in a pattern, for example within the
|
||||
sequence (?( which introduces a conditional subpattern.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_EXTRA
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
This option was invented in order to turn on additional functionality of PCRE
|
||||
that is incompatible with Perl, but it is currently of very little use. When
|
||||
set, any backslash in a pattern that is followed by a letter that has no
|
||||
special meaning causes an error, thus reserving these combinations for future
|
||||
expansion. By default, as in Perl, a backslash followed by a letter with no
|
||||
special meaning is treated as a literal. There are at present no other features
|
||||
controlled by this option. It can also be set by a (?X) option setting within a
|
||||
pattern.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_MULTILINE
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
By default, PCRE treats the subject string as consisting of a single "line" of
|
||||
characters (even if it actually contains several newlines). The "start of line"
|
||||
metacharacter (^) matches only at the start of the string, while the "end of
|
||||
line" metacharacter ($) matches only at the end of the string, or before a
|
||||
terminating newline (unless PCRE_DOLLAR_ENDONLY is set). This is the same as
|
||||
Perl.
|
||||
</P>
|
||||
<P>
|
||||
When PCRE_MULTILINE it is set, the "start of line" and "end of line" constructs
|
||||
match immediately following or immediately before any newline in the subject
|
||||
string, respectively, as well as at the very start and end. This is equivalent
|
||||
to Perl's /m option. If there are no "\n" characters in a subject string, or
|
||||
no occurrences of ^ or $ in a pattern, setting PCRE_MULTILINE has no
|
||||
effect.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_UNGREEDY
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
This option inverts the "greediness" of the quantifiers so that they are not
|
||||
greedy by default, but become greedy if followed by "?". It is not compatible
|
||||
with Perl. It can also be set by a (?U) option setting within the pattern.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_UTF8
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
This option causes PCRE to regard both the pattern and the subject as strings
|
||||
of UTF-8 characters instead of just byte strings. However, it is available only
|
||||
if PCRE has been built to include UTF-8 support. If not, the use of this option
|
||||
provokes an error. Support for UTF-8 is new, experimental, and incomplete.
|
||||
Details of exactly what it entails are given below.
|
||||
</P>
|
||||
<LI><A NAME="SEC6" HREF="#TOC1">STUDYING A PATTERN</A>
|
||||
<P>
|
||||
When a pattern is going to be used several times, it is worth spending more
|
||||
time analyzing it in order to speed up the time taken for matching. The
|
||||
function <B>pcre_study()</B> takes a pointer to a compiled pattern as its first
|
||||
argument, and returns a pointer to a <B>pcre_extra</B> block (another <B>void</B>
|
||||
typedef) containing additional information about the pattern; this can be
|
||||
passed to <B>pcre_exec()</B>. If no additional information is available, NULL
|
||||
is returned.
|
||||
</P>
|
||||
<P>
|
||||
The second argument contains option bits. At present, two options are
|
||||
defined for <B>pcre_study()</B>, PCRE_STUDY_NO_PRUNE and PCRE_STUDY_NO_START,
|
||||
which skip one of the available regex-studying algorithms.
|
||||
</P>
|
||||
<P>
|
||||
The third argument for <B>pcre_study()</B> is a pointer to an error message. If
|
||||
studying succeeds (even if no data is returned), the variable it points to is
|
||||
set to NULL. Otherwise it points to a textual error message.
|
||||
</P>
|
||||
<P>
|
||||
Studying a pattern is very useful for non-anchored patterns that do
|
||||
not have a single fixed starting character or that start with a fixed-length
|
||||
(no stars) pattern, because in this case PCRE builds data structures that
|
||||
allow the matcher to skip several characters when looking for a place to
|
||||
start matching. This study can be inhibited by PCRE_STUDY_NO_START.
|
||||
</P>
|
||||
<P>
|
||||
In addition, when PCRE_STUDY_NO_PRUNE is not specified, <B>pcre_study()</B>
|
||||
tries to cut backtracking paths by looking for constructs such as [^;]*;
|
||||
or \d*\. (if digits are to be followed by a period, which is not a digit,
|
||||
there's no use in backtracking). This often can limit the exponential
|
||||
behavior of the matcher and speed up failing attempts to match a pattern.
|
||||
</P>
|
||||
<LI><A NAME="SEC7" HREF="#TOC1">LOCALE SUPPORT</A>
|
||||
<P>
|
||||
PCRE handles caseless matching, and determines whether characters are letters,
|
||||
digits, or whatever, by reference to a set of tables. The library contains a
|
||||
default set of tables which is created in the default C locale when PCRE is
|
||||
compiled. This is used when the final argument of <B>pcre_compile()</B> is NULL,
|
||||
and is sufficient for many applications.
|
||||
</P>
|
||||
<P>
|
||||
An alternative set of tables can, however, be supplied. Such tables are built
|
||||
by calling the <B>pcre_maketables()</B> function, which has no arguments, in the
|
||||
relevant locale. The result can then be passed to <B>pcre_compile()</B> as often
|
||||
as necessary. For example, to build and use tables that are appropriate for the
|
||||
French locale (where accented characters with codes greater than 128 are
|
||||
treated as letters), the following code could be used:
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
setlocale(LC_CTYPE, "fr");
|
||||
tables = pcre_maketables();
|
||||
re = pcre_compile(..., tables);
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
The tables are built in memory that is obtained via <B>pcre_malloc</B>. The
|
||||
pointer that is passed to <B>pcre_compile</B> is saved with the compiled
|
||||
pattern, and the same tables are used via this pointer by <B>pcre_study()</B>
|
||||
and <B>pcre_exec()</B>. Thus for any single pattern, compilation, studying and
|
||||
matching all happen in the same locale, but different patterns can be compiled
|
||||
in different locales. It is the caller's responsibility to ensure that the
|
||||
memory containing the tables remains available for as long as it is needed.
|
||||
</P>
|
||||
<LI><A NAME="SEC8" HREF="#TOC1">INFORMATION ABOUT A PATTERN</A>
|
||||
<P>
|
||||
The <B>pcre_fullinfo()</B> function returns information about a compiled
|
||||
pattern. The first argument for <B>pcre_fullinfo()</B> is a pointer to the
|
||||
compiled pattern. The second argument is the result of <B>pcre_study()</B>,
|
||||
or NULL if the pattern was not studied. The third argument specifies which
|
||||
piece of information is required, while the fourth argument is a pointer to a
|
||||
variable to receive the data. The yield of the function is zero for success,
|
||||
or one of the following negative numbers:
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_ERROR_NULL the argument <I>code</I> was NULL
|
||||
the argument <I>where</I> was NULL
|
||||
PCRE_ERROR_BADMAGIC the "magic number" was not found
|
||||
PCRE_ERROR_BADOPTION the value of <I>what</I> was invalid
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
The possible values for the third argument are defined in <B>pcre.h</B>, and are
|
||||
as follows:
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_INFO_OPTIONS
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
Return a copy of the options with which the pattern was compiled. The fourth
|
||||
argument should point to au <B>unsigned long int</B> variable. These option bits
|
||||
are those specified in the call to <B>pcre_compile()</B>, modified by any
|
||||
top-level option settings within the pattern itself, and with the PCRE_ANCHORED
|
||||
bit forcibly set if the form of the pattern implies that it can match only at
|
||||
the start of a subject string.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_INFO_SIZE
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
Return the size of the compiled pattern, that is, the value that was passed as
|
||||
the argument to <B>pcre_malloc()</B> when PCRE was getting memory in which to
|
||||
place the compiled data. The fourth argument should point to a <B>size_t</B>
|
||||
variable.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_INFO_CAPTURECOUNT
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
Return the number of capturing subpatterns in the pattern. The fourth argument
|
||||
should point to an \fbint\fR variable.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_INFO_BACKREFMAX
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
Return the number of the highest back reference in the pattern. The fourth
|
||||
argument should point to an <B>int</B> variable. Zero is returned if there are
|
||||
no back references.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_INFO_FIRSTCHAR
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
Return information about the first character of any matched string, for a
|
||||
non-anchored pattern. If there is a fixed first character, e.g. from a pattern
|
||||
such as (cat|cow|coyote), it is returned in the integer pointed to by
|
||||
<I>where</I>. Otherwise, if either
|
||||
</P>
|
||||
<P>
|
||||
(a) the pattern was compiled with the PCRE_MULTILINE option, and every branch
|
||||
starts with "^", or
|
||||
</P>
|
||||
<P>
|
||||
(b) every branch of the pattern starts with ".*" and PCRE_DOTALL is not set
|
||||
(if it were set, the pattern would be anchored),
|
||||
</P>
|
||||
<P>
|
||||
-1 is returned, indicating that the pattern matches only at the start of a
|
||||
subject string or after any "\n" within the string. Otherwise -2 is returned.
|
||||
For anchored patterns, -2 is returned.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_INFO_FIRSTTABLE
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
If the pattern was studied, and this resulted in the construction of a 256-bit
|
||||
table indicating a fixed set of characters for the first character in any
|
||||
matching string, a pointer to the table is returned. Otherwise NULL is
|
||||
returned. The fourth argument should point to an <B>unsigned char *</B>
|
||||
variable.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_INFO_LASTLITERAL
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
For a non-anchored pattern, return the value of the rightmost literal character
|
||||
which must exist in any matched string, other than at its start. The fourth
|
||||
argument should point to an <B>int</B> variable. If there is no such character,
|
||||
or if the pattern is anchored, -1 is returned. For example, for the pattern
|
||||
/a\d+z\d+/ the returned value is 'z'.
|
||||
</P>
|
||||
<P>
|
||||
</P>
|
||||
<LI><A NAME="SEC9" HREF="#TOC1">MATCHING A PATTERN</A>
|
||||
<P>
|
||||
The function <B>pcre_exec()</B> is called to match a subject string against a
|
||||
pre-compiled pattern, which is passed in the <I>code</I> argument. If the
|
||||
pattern has been studied, the result of the study should be passed in the
|
||||
<I>extra</I> argument. Otherwise this must be NULL.
|
||||
</P>
|
||||
<P>
|
||||
The PCRE_ANCHORED option can be passed in the <I>options</I> argument, whose
|
||||
unused bits must be zero. However, if a pattern was compiled with
|
||||
PCRE_ANCHORED, or turned out to be anchored by virtue of its contents, it
|
||||
cannot be made unachored at matching time.
|
||||
</P>
|
||||
<P>
|
||||
There are also three further options that can be set only at matching time:
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_NOTBOL
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
The first character of the string is not the beginning of a line, so the
|
||||
circumflex metacharacter should not match before it. Setting this without
|
||||
PCRE_MULTILINE (at compile time) causes circumflex never to match.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_NOTEOL
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
The end of the string is not the end of a line, so the dollar metacharacter
|
||||
should not match it nor (except in multiline mode) a newline immediately before
|
||||
it. Setting this without PCRE_MULTILINE (at compile time) causes dollar never
|
||||
to match.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_NOTEMPTY
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
An empty string is not considered to be a valid match if this option is set. If
|
||||
there are alternatives in the pattern, they are tried. If all the alternatives
|
||||
match the empty string, the entire match fails. For example, if the pattern
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
a?b?
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
is applied to a string not beginning with "a" or "b", it matches the empty
|
||||
string at the start of the subject. With PCRE_NOTEMPTY set, this match is not
|
||||
valid, so PCRE searches further into the string for occurrences of "a" or "b".
|
||||
</P>
|
||||
<P>
|
||||
Perl has no direct equivalent of PCRE_NOTEMPTY, but it does make a special case
|
||||
of a pattern match of the empty string within its <B>split()</B> function, and
|
||||
when using the /g modifier. It is possible to emulate Perl's behaviour after
|
||||
matching a null string by first trying the match again at the same offset with
|
||||
PCRE_NOTEMPTY set, and then if that fails by advancing the starting offset (see
|
||||
below) and trying an ordinary match again.
|
||||
</P>
|
||||
<P>
|
||||
The subject string is passed as a pointer in <I>subject</I>, a length in
|
||||
<I>length</I>, and a starting offset in <I>startoffset</I>. Unlike the pattern
|
||||
string, it may contain binary zero characters. When the starting offset is
|
||||
zero, the search for a match starts at the beginning of the subject, and this
|
||||
is by far the most common case.
|
||||
</P>
|
||||
<P>
|
||||
A non-zero starting offset is useful when searching for another match in the
|
||||
same subject by calling <B>pcre_exec()</B> again after a previous success.
|
||||
Setting <I>startoffset</I> differs from just passing over a shortened string and
|
||||
setting PCRE_NOTBOL in the case of a pattern that begins with any kind of
|
||||
lookbehind. For example, consider the pattern
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
\Biss\B
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
which finds occurrences of "iss" in the middle of words. (\B matches only if
|
||||
the current position in the subject is not a word boundary.) When applied to
|
||||
the string "Mississipi" the first call to <B>pcre_exec()</B> finds the first
|
||||
occurrence. If <B>pcre_exec()</B> is called again with just the remainder of the
|
||||
subject, namely "issipi", it does not match, because \B is always false at the
|
||||
start of the subject, which is deemed to be a word boundary. However, if
|
||||
<B>pcre_exec()</B> is passed the entire string again, but with <I>startoffset</I>
|
||||
set to 4, it finds the second occurrence of "iss" because it is able to look
|
||||
behind the starting point to discover that it is preceded by a letter.
|
||||
</P>
|
||||
<P>
|
||||
If a non-zero starting offset is passed when the pattern is anchored, one
|
||||
attempt to match at the given offset is tried. This can only succeed if the
|
||||
pattern does not require the match to be at the start of the subject.
|
||||
</P>
|
||||
<P>
|
||||
In general, a pattern matches a certain portion of the subject, and in
|
||||
addition, further substrings from the subject may be picked out by parts of the
|
||||
pattern. Following the usage in Jeffrey Friedl's book, this is called
|
||||
"capturing" in what follows, and the phrase "capturing subpattern" is used for
|
||||
a fragment of a pattern that picks out a substring. PCRE supports several other
|
||||
kinds of parenthesized subpattern that do not cause substrings to be captured.
|
||||
</P>
|
||||
<P>
|
||||
Captured substrings are returned to the caller via a vector of integer offsets
|
||||
whose address is passed in <I>ovector</I>. The number of elements in the vector
|
||||
is passed in <I>ovecsize</I>. The first two-thirds of the vector is used to pass
|
||||
back captured substrings, each substring using a pair of integers. The
|
||||
remaining third of the vector is used as workspace by <B>pcre_exec()</B> while
|
||||
matching capturing subpatterns, and is not available for passing back
|
||||
information. The length passed in <I>ovecsize</I> should always be a multiple of
|
||||
three. If it is not, it is rounded down.
|
||||
</P>
|
||||
<P>
|
||||
When a match has been successful, information about captured substrings is
|
||||
returned in pairs of integers, starting at the beginning of <I>ovector</I>, and
|
||||
continuing up to two-thirds of its length at the most. The first element of a
|
||||
pair is set to the offset of the first character in a substring, and the second
|
||||
is set to the offset of the first character after the end of a substring. The
|
||||
first pair, <I>ovector[0]</I> and <I>ovector[1]</I>, identify the portion of the
|
||||
subject string matched by the entire pattern. The next pair is used for the
|
||||
first capturing subpattern, and so on. The value returned by <B>pcre_exec()</B>
|
||||
is the number of pairs that have been set. If there are no capturing
|
||||
subpatterns, the return value from a successful match is 1, indicating that
|
||||
just the first pair of offsets has been set.
|
||||
</P>
|
||||
<P>
|
||||
Some convenience functions are provided for extracting the captured substrings
|
||||
as separate strings. These are described in the following section.
|
||||
</P>
|
||||
<P>
|
||||
It is possible for an capturing subpattern number <I>n+1</I> to match some
|
||||
part of the subject when subpattern <I>n</I> has not been used at all. For
|
||||
example, if the string "abc" is matched against the pattern (a|(z))(bc)
|
||||
subpatterns 1 and 3 are matched, but 2 is not. When this happens, both offset
|
||||
values corresponding to the unused subpattern are set to -1.
|
||||
</P>
|
||||
<P>
|
||||
If a capturing subpattern is matched repeatedly, it is the last portion of the
|
||||
string that it matched that gets returned.
|
||||
</P>
|
||||
<P>
|
||||
If the vector is too small to hold all the captured substrings, it is used as
|
||||
far as possible (up to two-thirds of its length), and the function returns a
|
||||
value of zero. In particular, if the substring offsets are not of interest,
|
||||
<B>pcre_exec()</B> may be called with <I>ovector</I> passed as NULL and
|
||||
<I>ovecsize</I> as zero. However, if the pattern contains back references and
|
||||
the <I>ovector</I> isn't big enough to remember the related substrings, PCRE has
|
||||
to get additional memory for use during matching. Thus it is usually advisable
|
||||
to supply an <I>ovector</I>.
|
||||
</P>
|
||||
<P>
|
||||
Note that <B>pcre_info()</B> can be used to find out how many capturing
|
||||
subpatterns there are in a compiled pattern. The smallest size for
|
||||
<I>ovector</I> that will allow for <I>n</I> captured substrings in addition to
|
||||
the offsets of the substring matched by the whole pattern is (<I>n</I>+1)*3.
|
||||
</P>
|
||||
<P>
|
||||
If <B>pcre_exec()</B> fails, it returns a negative number. The following are
|
||||
defined in the header file:
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_ERROR_NOMATCH (-1)
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
The subject string did not match the pattern.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_ERROR_NULL (-2)
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
Either <I>code</I> or <I>subject</I> was passed as NULL, or <I>ovector</I> was
|
||||
NULL and <I>ovecsize</I> was not zero.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_ERROR_BADOPTION (-3)
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
An unrecognized bit was set in the <I>options</I> argument.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_ERROR_BADMAGIC (-4)
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
PCRE stores a 4-byte "magic number" at the start of the compiled code, to catch
|
||||
the case when it is passed a junk pointer. This is the error it gives when the
|
||||
magic number isn't present.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_ERROR_UNKNOWN_NODE (-5)
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
While running the pattern match, an unknown item was encountered in the
|
||||
compiled pattern. This error could be caused by a bug in PCRE or by overwriting
|
||||
of the compiled pattern.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_ERROR_NOMEMORY (-6)
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
If a pattern contains back references, but the <I>ovector</I> that is passed to
|
||||
<B>pcre_exec()</B> is not big enough to remember the referenced substrings, PCRE
|
||||
gets a block of memory at the start of matching to use for this purpose. If the
|
||||
call via <B>pcre_malloc()</B> fails, this error is given. The memory is freed at
|
||||
the end of matching.
|
||||
</P>
|
||||
<LI><A NAME="SEC10" HREF="#TOC1">EXTRACTING CAPTURED SUBSTRINGS</A>
|
||||
<P>
|
||||
Captured substrings can be accessed directly by using the offsets returned by
|
||||
<B>pcre_exec()</B> in <I>ovector</I>. For convenience, the functions
|
||||
<B>pcre_copy_substring()</B>, <B>pcre_get_substring()</B>, and
|
||||
<B>pcre_get_substring_list()</B> are provided for extracting captured substrings
|
||||
as new, separate, zero-terminated strings. A substring that contains a binary
|
||||
zero is correctly extracted and has a further zero added on the end, but the
|
||||
result does not, of course, function as a C string.
|
||||
</P>
|
||||
<P>
|
||||
The first three arguments are the same for all three functions: <I>subject</I>
|
||||
is the subject string which has just been successfully matched, <I>ovector</I>
|
||||
is a pointer to the vector of integer offsets that was passed to
|
||||
<B>pcre_exec()</B>, and <I>stringcount</I> is the number of substrings that
|
||||
were captured by the match, including the substring that matched the entire
|
||||
regular expression. This is the value returned by <B>pcre_exec</B> if it
|
||||
is greater than zero. If <B>pcre_exec()</B> returned zero, indicating that it
|
||||
ran out of space in <I>ovector</I>, the value passed as <I>stringcount</I> should
|
||||
be the size of the vector divided by three.
|
||||
</P>
|
||||
<P>
|
||||
The functions <B>pcre_copy_substring()</B> and <B>pcre_get_substring()</B>
|
||||
extract a single substring, whose number is given as <I>stringnumber</I>. A
|
||||
value of zero extracts the substring that matched the entire pattern, while
|
||||
higher values extract the captured substrings. For <B>pcre_copy_substring()</B>,
|
||||
the string is placed in <I>buffer</I>, whose length is given by
|
||||
<I>buffersize</I>, while for <B>pcre_get_substring()</B> a new block of memory is
|
||||
obtained via <B>pcre_malloc</B>, and its address is returned via
|
||||
<I>stringptr</I>. The yield of the function is the length of the string, not
|
||||
including the terminating zero, or one of
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_ERROR_NOMEMORY (-6)
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
The buffer was too small for <B>pcre_copy_substring()</B>, or the attempt to get
|
||||
memory failed for <B>pcre_get_substring()</B>.
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_ERROR_NOSUBSTRING (-7)
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
There is no substring whose number is <I>stringnumber</I>.
|
||||
</P>
|
||||
<P>
|
||||
The <B>pcre_get_substring_list()</B> function extracts all available substrings
|
||||
and builds a list of pointers to them. All this is done in a single block of
|
||||
memory which is obtained via <B>pcre_malloc</B>. The address of the memory block
|
||||
is returned via <I>listptr</I>, which is also the start of the list of string
|
||||
pointers. The end of the list is marked by a NULL pointer. The yield of the
|
||||
function is zero if all went well, or
|
||||
</P>
|
||||
<P>
|
||||
<PRE>
|
||||
PCRE_ERROR_NOMEMORY (-6)
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
if the attempt to get the memory block failed.
|
||||
</P>
|
||||
<P>
|
||||
When any of these functions encounter a substring that is unset, which can
|
||||
happen when capturing subpattern number <I>n+1</I> matches some part of the
|
||||
subject, but subpattern <I>n</I> has not been used at all, they return an empty
|
||||
string. This can be distinguished from a genuine zero-length substring by
|
||||
inspecting the appropriate offset in <I>ovector</I>, which is negative for unset
|
||||
substrings.
|
||||
</P>
|
||||
<P>
|
||||
The two convenience functions <B>pcre_free_substring()</B> and
|
||||
<B>pcre_free_substring_list()</B> can be used to free the memory returned by
|
||||
a previous call of <B>pcre_get_substring()</B> or
|
||||
<B>pcre_get_substring_list()</B>, respectively. They do nothing more than call
|
||||
the function pointed to by <B>pcre_free</B>, which of course could be called
|
||||
directly from a C program. However, PCRE is used in some situations where it is
|
||||
linked via a special interface to another programming language which cannot use
|
||||
<B>pcre_free</B> directly; it is for these cases that the functions are
|
||||
provided.
|
||||
</P>
|
||||
<LI><A NAME="SEC11" HREF="#TOC1">AUTHOR</A>
|
||||
<P>
|
||||
Philip Hazel <ph10@cam.ac.uk>
|
||||
<BR>
|
||||
University Computing Service,
|
||||
<BR>
|
||||
New Museums Site,
|
||||
<BR>
|
||||
Cambridge CB2 3QG, England.
|
||||
<BR>
|
||||
Phone: +44 1223 334714
|
||||
</P>
|
||||
<P>
|
||||
Last updated: 28 August 2000,
|
||||
<BR>
|
||||
<PRE>
|
||||
the 250th anniversary of the death of J.S. Bach.
|
||||
<BR>
|
||||
</PRE>
|
||||
Copyright (c) 1997-2000 University of Cambridge.
|
||||
@@ -1,7 +1,7 @@
|
||||
.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.28.
|
||||
.TH SED "1" "August 2004" "sed version 4.1.2" "User Commands"
|
||||
.TH SUPER-SED "1" "March 2004" "super-sed version 3.61" "User Commands"
|
||||
.SH NAME
|
||||
sed \- manual page for sed version 4.1.2
|
||||
super-sed \- manual page for super-sed version 3.61
|
||||
.SH SYNOPSIS
|
||||
.B sed
|
||||
[\fIOPTION\fR]... \fI{script-only-if-no-other-script} \fR[\fIinput-file\fR]...
|
||||
@@ -19,7 +19,7 @@ input(s), and is consequently more efficient.
|
||||
But it is \*(sd's ability to filter text in a pipeline
|
||||
which particularly distinguishes it from other types of
|
||||
editors.
|
||||
.HP
|
||||
.PP
|
||||
\fB\-n\fR, \fB\-\-quiet\fR, \fB\-\-silent\fR
|
||||
.IP
|
||||
suppress automatic printing of pattern space
|
||||
@@ -48,6 +48,10 @@ disable all GNU extensions.
|
||||
.IP
|
||||
use extended regular expressions in the script.
|
||||
.HP
|
||||
\fB\-R\fR, \fB\-\-regexp\-perl\fR
|
||||
.IP
|
||||
use Perl 5's regular expressions syntax in the script.
|
||||
.HP
|
||||
\fB\-s\fR, \fB\-\-separate\fR
|
||||
.IP
|
||||
consider files as separate rather than as a single continuous
|
||||
@@ -70,7 +74,9 @@ remaining arguments are names of input files; if no input files are
|
||||
specified, then the standard input is read.
|
||||
.PP
|
||||
E-mail bug reports to: bonzini@gnu.org .
|
||||
Be sure to include the word ``sed'' somewhere in the ``Subject:'' field.
|
||||
Be sure to include the word ``ssed'' somewhere in the ``Subject:'' field.
|
||||
.PP
|
||||
based on GNU sed version 4.1
|
||||
.SH "COMMAND SYNOPSIS"
|
||||
This is just a brief synopsis of \*(sd commands to serve as
|
||||
a reminder to those who already know \*(sd;
|
||||
@@ -362,11 +368,11 @@ the \*(sd FAQ (http://sed.sf.net/grabbag/tutorials/sedfaq.html),
|
||||
http://sed.sf.net/grabbag/.
|
||||
.PP
|
||||
The full documentation for
|
||||
.B sed
|
||||
.B super-sed
|
||||
is maintained as a Texinfo manual. If the
|
||||
.B info
|
||||
and
|
||||
.B sed
|
||||
.B super-sed
|
||||
programs are properly installed at your site, the command
|
||||
.IP
|
||||
.B info sed
|
||||
|
||||
+6
-7
@@ -1,16 +1,15 @@
|
||||
## Process this file with automake to produce Makefile.in
|
||||
noinst_LIBRARIES = libsed.a
|
||||
noinst_HEADERS = getopt.h utils.h obstack.h regex_.h regex_internal.h \
|
||||
strverscmp.h stdbool_.h
|
||||
noinst_HEADERS = getopt.h utils.h obstack.h strverscmp.h \
|
||||
stdbool_.h
|
||||
|
||||
libsed_a_SOURCES = getopt1.c getopt.c utils.c
|
||||
EXTRA_DIST = memmove.c strerror.c
|
||||
|
||||
EXTRA_DIST = memmove.c strerror.c regcomp.c regexec.c regex_internal.c
|
||||
|
||||
AM_CPPFLAGS = -I$(top_srcdir)/lib -I$(top_srcdir)/intl -I$(top_srcdir) \
|
||||
-I$(top_builddir)/lib
|
||||
AM_CPPFLAGS = -I$(top_srcdir)/lib -I$(top_srcdir)/intl -I$(top_srcdir)/pcre \
|
||||
-I$(top_srcdir)
|
||||
|
||||
libsed_a_LIBADD = @LIBOBJS@ @ALLOCA@
|
||||
libsed_a_DEPENDENCIES = $(libsed_a_LIBADD)
|
||||
|
||||
DISTCLEANFILES = regex.h stdbool.h
|
||||
DISTCLEANFILES = stdbool.h
|
||||
-3793
File diff suppressed because it is too large.
Load diff
-97
@@ -1,97 +0,0 @@
|
||||
/* Extended regular expression matching and search library.
|
||||
Copyright (C) 2002, 2003 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
Contributed by Isamu Hasegawa <isamu@yamato.ibm.com>.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
The GNU C Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with the GNU C Library; if not, write to the Free
|
||||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA. */
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#ifdef _AIX
|
||||
#pragma alloca
|
||||
#else
|
||||
# ifndef allocax /* predefined by HP cc +Olibcalls */
|
||||
# ifdef __GNUC__
|
||||
# define alloca(size) __builtin_alloca (size)
|
||||
# else
|
||||
# if HAVE_ALLOCA_H
|
||||
# include <alloca.h>
|
||||
# else
|
||||
# ifdef __hpux
|
||||
void *alloca ();
|
||||
# else
|
||||
# if !defined __OS2__ && !defined WIN32
|
||||
char *alloca ();
|
||||
# else
|
||||
# include <malloc.h> /* OS/2 defines alloca in here */
|
||||
# endif
|
||||
# endif
|
||||
# endif
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef _LIBC
|
||||
/* We have to keep the namespace clean. */
|
||||
# define regfree(preg) __regfree (preg)
|
||||
# define regexec(pr, st, nm, pm, ef) __regexec (pr, st, nm, pm, ef)
|
||||
# define regcomp(preg, pattern, cflags) __regcomp (preg, pattern, cflags)
|
||||
# define regerror(errcode, preg, errbuf, errbuf_size) \
|
||||
__regerror(errcode, preg, errbuf, errbuf_size)
|
||||
# define re_set_registers(bu, re, nu, st, en) \
|
||||
__re_set_registers (bu, re, nu, st, en)
|
||||
# define re_match_2(bufp, string1, size1, string2, size2, pos, regs, stop) \
|
||||
__re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
|
||||
# define re_match(bufp, string, size, pos, regs) \
|
||||
__re_match (bufp, string, size, pos, regs)
|
||||
# define re_search(bufp, string, size, startpos, range, regs) \
|
||||
__re_search (bufp, string, size, startpos, range, regs)
|
||||
# define re_compile_pattern(pattern, length, bufp) \
|
||||
__re_compile_pattern (pattern, length, bufp)
|
||||
# define re_set_syntax(syntax) __re_set_syntax (syntax)
|
||||
# define re_search_2(bufp, st1, s1, st2, s2, startpos, range, regs, stop) \
|
||||
__re_search_2 (bufp, st1, s1, st2, s2, startpos, range, regs, stop)
|
||||
# define re_compile_fastmap(bufp) __re_compile_fastmap (bufp)
|
||||
|
||||
# include "../locale/localeinfo.h"
|
||||
#endif
|
||||
|
||||
/* POSIX says that <sys/types.h> must be included (by the caller) before
|
||||
<regex.h>. */
|
||||
#include <sys/types.h>
|
||||
|
||||
/* On some systems, limits.h sets RE_DUP_MAX to a lower value than
|
||||
GNU regex allows. Include it before <regex.h>, which correctly
|
||||
#undefs RE_DUP_MAX and sets it to the right value. */
|
||||
#include <limits.h>
|
||||
|
||||
#include <regex.h>
|
||||
#include "regex_internal.h"
|
||||
|
||||
#include "regex_internal.c"
|
||||
#include "regcomp.c"
|
||||
#include "regexec.c"
|
||||
|
||||
/* Binary backward compatibility. */
|
||||
#if _LIBC
|
||||
# include <shlib-compat.h>
|
||||
# if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_3)
|
||||
link_warning (re_max_failures, "the 're_max_failures' variable is obsolete and will go away.")
|
||||
int re_max_failures = 2000;
|
||||
# endif
|
||||
#endif
|
||||
-588
@@ -1,588 +0,0 @@
|
||||
/* Definitions for data structures and routines for the regular
|
||||
expression library.
|
||||
Copyright (C) 1985,1989-93,1995-98,2000,2001,2002,2003
|
||||
Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
The GNU C Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with the GNU C Library; if not, write to the Free
|
||||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA. */
|
||||
|
||||
#ifndef _REGEX_H
|
||||
#define _REGEX_H 1
|
||||
|
||||
#include <sys/types.h>
|
||||
|
||||
/* Allow the use in C++ code. */
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* POSIX says that <sys/types.h> must be included (by the caller) before
|
||||
<regex.h>. */
|
||||
|
||||
#if !defined _POSIX_C_SOURCE && !defined _POSIX_SOURCE && defined VMS
|
||||
/* VMS doesn't have `size_t' in <sys/types.h>, even though POSIX says it
|
||||
should be there. */
|
||||
# include <stddef.h>
|
||||
#endif
|
||||
|
||||
/* The following two types have to be signed and unsigned integer type
|
||||
wide enough to hold a value of a pointer. For most ANSI compilers
|
||||
ptrdiff_t and size_t should be likely OK. Still size of these two
|
||||
types is 2 for Microsoft C. Ugh... */
|
||||
typedef long int s_reg_t;
|
||||
typedef unsigned long int active_reg_t;
|
||||
|
||||
/* The following bits are used to determine the regexp syntax we
|
||||
recognize. The set/not-set meanings are chosen so that Emacs syntax
|
||||
remains the value 0. The bits are given in alphabetical order, and
|
||||
the definitions shifted by one from the previous bit; thus, when we
|
||||
add or remove a bit, only one other definition need change. */
|
||||
typedef unsigned long int reg_syntax_t;
|
||||
|
||||
/* If this bit is not set, then \ inside a bracket expression is literal.
|
||||
If set, then such a \ quotes the following character. */
|
||||
#define RE_BACKSLASH_ESCAPE_IN_LISTS ((unsigned long int) 1)
|
||||
|
||||
/* If this bit is not set, then + and ? are operators, and \+ and \? are
|
||||
literals.
|
||||
If set, then \+ and \? are operators and + and ? are literals. */
|
||||
#define RE_BK_PLUS_QM (RE_BACKSLASH_ESCAPE_IN_LISTS << 1)
|
||||
|
||||
/* If this bit is set, then character classes are supported. They are:
|
||||
[:alpha:], [:upper:], [:lower:], [:digit:], [:alnum:], [:xdigit:],
|
||||
[:space:], [:print:], [:punct:], [:graph:], and [:cntrl:].
|
||||
If not set, then character classes are not supported. */
|
||||
#define RE_CHAR_CLASSES (RE_BK_PLUS_QM << 1)
|
||||
|
||||
/* If this bit is set, then ^ and $ are always anchors (outside bracket
|
||||
expressions, of course).
|
||||
If this bit is not set, then it depends:
|
||||
^ is an anchor if it is at the beginning of a regular
|
||||
expression or after an open-group or an alternation operator;
|
||||
$ is an anchor if it is at the end of a regular expression, or
|
||||
before a close-group or an alternation operator.
|
||||
|
||||
This bit could be (re)combined with RE_CONTEXT_INDEP_OPS, because
|
||||
POSIX draft 11.2 says that * etc. in leading positions is undefined.
|
||||
We already implemented a previous draft which made those constructs
|
||||
invalid, though, so we haven't changed the code back. */
|
||||
#define RE_CONTEXT_INDEP_ANCHORS (RE_CHAR_CLASSES << 1)
|
||||
|
||||
/* If this bit is set, then special characters are always special
|
||||
regardless of where they are in the pattern.
|
||||
If this bit is not set, then special characters are special only in
|
||||
some contexts; otherwise they are ordinary. Specifically,
|
||||
* + ? and intervals are only special when not after the beginning,
|
||||
open-group, or alternation operator. */
|
||||
#define RE_CONTEXT_INDEP_OPS (RE_CONTEXT_INDEP_ANCHORS << 1)
|
||||
|
||||
/* If this bit is set, then *, +, ?, and { cannot be first in an re or
|
||||
immediately after an alternation or begin-group operator. */
|
||||
#define RE_CONTEXT_INVALID_OPS (RE_CONTEXT_INDEP_OPS << 1)
|
||||
|
||||
/* If this bit is set, then . matches newline.
|
||||
If not set, then it doesn't. */
|
||||
#define RE_DOT_NEWLINE (RE_CONTEXT_INVALID_OPS << 1)
|
||||
|
||||
/* If this bit is set, then . doesn't match NUL.
|
||||
If not set, then it does. */
|
||||
#define RE_DOT_NOT_NULL (RE_DOT_NEWLINE << 1)
|
||||
|
||||
/* If this bit is set, nonmatching lists [^...] do not match newline.
|
||||
If not set, they do. */
|
||||
#define RE_HAT_LISTS_NOT_NEWLINE (RE_DOT_NOT_NULL << 1)
|
||||
|
||||
/* If this bit is set, either \{...\} or {...} defines an
|
||||
interval, depending on RE_NO_BK_BRACES.
|
||||
If not set, \{, \}, {, and } are literals. */
|
||||
#define RE_INTERVALS (RE_HAT_LISTS_NOT_NEWLINE << 1)
|
||||
|
||||
/* If this bit is set, +, ? and | aren't recognized as operators.
|
||||
If not set, they are. */
|
||||
#define RE_LIMITED_OPS (RE_INTERVALS << 1)
|
||||
|
||||
/* If this bit is set, newline is an alternation operator.
|
||||
If not set, newline is literal. */
|
||||
#define RE_NEWLINE_ALT (RE_LIMITED_OPS << 1)
|
||||
|
||||
/* If this bit is set, then `{...}' defines an interval, and \{ and \}
|
||||
are literals.
|
||||
If not set, then `\{...\}' defines an interval. */
|
||||
#define RE_NO_BK_BRACES (RE_NEWLINE_ALT << 1)
|
||||
|
||||
/* If this bit is set, (...) defines a group, and \( and \) are literals.
|
||||
If not set, \(...\) defines a group, and ( and ) are literals. */
|
||||
#define RE_NO_BK_PARENS (RE_NO_BK_BRACES << 1)
|
||||
|
||||
/* If this bit is set, then \<digit> matches <digit>.
|
||||
If not set, then \<digit> is a back-reference. */
|
||||
#define RE_NO_BK_REFS (RE_NO_BK_PARENS << 1)
|
||||
|
||||
/* If this bit is set, then | is an alternation operator, and \| is literal.
|
||||
If not set, then \| is an alternation operator, and | is literal. */
|
||||
#define RE_NO_BK_VBAR (RE_NO_BK_REFS << 1)
|
||||
|
||||
/* If this bit is set, then an ending range point collating higher
|
||||
than the starting range point, as in [z-a], is invalid.
|
||||
If not set, then when ending range point collates higher than the
|
||||
starting range point, the range is ignored. */
|
||||
#define RE_NO_EMPTY_RANGES (RE_NO_BK_VBAR << 1)
|
||||
|
||||
/* If this bit is set, then an unmatched ) is ordinary.
|
||||
If not set, then an unmatched ) is invalid. */
|
||||
#define RE_UNMATCHED_RIGHT_PAREN_ORD (RE_NO_EMPTY_RANGES << 1)
|
||||
|
||||
/* If this bit is set, succeed as soon as we match the whole pattern,
|
||||
without further backtracking. */
|
||||
#define RE_NO_POSIX_BACKTRACKING (RE_UNMATCHED_RIGHT_PAREN_ORD << 1)
|
||||
|
||||
/* If this bit is set, do not process the GNU regex operators.
|
||||
If not set, then the GNU regex operators are recognized. */
|
||||
#define RE_NO_GNU_OPS (RE_NO_POSIX_BACKTRACKING << 1)
|
||||
|
||||
/* If this bit is set, turn on internal regex debugging.
|
||||
If not set, and debugging was on, turn it off.
|
||||
This only works if regex.c is compiled -DDEBUG.
|
||||
We define this bit always, so that all that's needed to turn on
|
||||
debugging is to recompile regex.c; the calling code can always have
|
||||
this bit set, and it won't affect anything in the normal case. */
|
||||
#define RE_DEBUG (RE_NO_GNU_OPS << 1)
|
||||
|
||||
/* If this bit is set, a syntactically invalid interval is treated as
|
||||
a string of ordinary characters. For example, the ERE 'a{1' is
|
||||
treated as 'a\{1'. */
|
||||
#define RE_INVALID_INTERVAL_ORD (RE_DEBUG << 1)
|
||||
|
||||
/* If this bit is set, then ignore case when matching.
|
||||
If not set, then case is significant. */
|
||||
#define RE_ICASE (RE_INVALID_INTERVAL_ORD << 1)
|
||||
|
||||
/* This bit is used internally like RE_CONTEXT_INDEP_ANCHORS but only
|
||||
for ^, because it is difficult to scan the regex backwards to find
|
||||
whether ^ should be special. */
|
||||
#define RE_CARET_ANCHORS_HERE (RE_ICASE << 1)
|
||||
|
||||
/* If this bit is set, then \{ cannot be first in an bre or
|
||||
immediately after an alternation or begin-group operator. */
|
||||
#define RE_CONTEXT_INVALID_DUP (RE_CARET_ANCHORS_HERE << 1)
|
||||
|
||||
/* This global variable defines the particular regexp syntax to use (for
|
||||
some interfaces). When a regexp is compiled, the syntax used is
|
||||
stored in the pattern buffer, so changing this does not affect
|
||||
already-compiled regexps. */
|
||||
extern reg_syntax_t re_syntax_options;
|
||||
|
||||
/* Define combinations of the above bits for the standard possibilities.
|
||||
(The [[[ comments delimit what gets put into the Texinfo file, so
|
||||
don't delete them!) */
|
||||
/* [[[begin syntaxes]]] */
|
||||
#define RE_SYNTAX_EMACS 0
|
||||
|
||||
#define RE_SYNTAX_AWK \
|
||||
(RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DOT_NOT_NULL \
|
||||
| RE_NO_BK_PARENS | RE_NO_BK_REFS \
|
||||
| RE_NO_BK_VBAR | RE_NO_EMPTY_RANGES \
|
||||
| RE_DOT_NEWLINE | RE_CONTEXT_INDEP_ANCHORS \
|
||||
| RE_UNMATCHED_RIGHT_PAREN_ORD | RE_NO_GNU_OPS)
|
||||
|
||||
#define RE_SYNTAX_GNU_AWK \
|
||||
((RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DEBUG) \
|
||||
& ~(RE_DOT_NOT_NULL | RE_INTERVALS | RE_CONTEXT_INDEP_OPS \
|
||||
| RE_CONTEXT_INVALID_OPS ))
|
||||
|
||||
#define RE_SYNTAX_POSIX_AWK \
|
||||
(RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS \
|
||||
| RE_INTERVALS | RE_NO_GNU_OPS)
|
||||
|
||||
#define RE_SYNTAX_GREP \
|
||||
(RE_BK_PLUS_QM | RE_CHAR_CLASSES \
|
||||
| RE_HAT_LISTS_NOT_NEWLINE | RE_INTERVALS \
|
||||
| RE_NEWLINE_ALT)
|
||||
|
||||
#define RE_SYNTAX_EGREP \
|
||||
(RE_CHAR_CLASSES | RE_CONTEXT_INDEP_ANCHORS \
|
||||
| RE_CONTEXT_INDEP_OPS | RE_HAT_LISTS_NOT_NEWLINE \
|
||||
| RE_NEWLINE_ALT | RE_NO_BK_PARENS \
|
||||
| RE_NO_BK_VBAR)
|
||||
|
||||
#define RE_SYNTAX_POSIX_EGREP \
|
||||
(RE_SYNTAX_EGREP | RE_INTERVALS | RE_NO_BK_BRACES \
|
||||
| RE_INVALID_INTERVAL_ORD)
|
||||
|
||||
/* P1003.2/D11.2, section 4.20.7.1, lines 5078ff. */
|
||||
#define RE_SYNTAX_ED RE_SYNTAX_POSIX_BASIC
|
||||
|
||||
#define RE_SYNTAX_SED RE_SYNTAX_POSIX_BASIC
|
||||
|
||||
/* Syntax bits common to both basic and extended POSIX regex syntax. */
|
||||
#define _RE_SYNTAX_POSIX_COMMON \
|
||||
(RE_CHAR_CLASSES | RE_DOT_NEWLINE | RE_DOT_NOT_NULL \
|
||||
| RE_INTERVALS | RE_NO_EMPTY_RANGES)
|
||||
|
||||
#define RE_SYNTAX_POSIX_BASIC \
|
||||
(_RE_SYNTAX_POSIX_COMMON | RE_BK_PLUS_QM | RE_CONTEXT_INVALID_DUP)
|
||||
|
||||
/* Differs from ..._POSIX_BASIC only in that RE_BK_PLUS_QM becomes
|
||||
RE_LIMITED_OPS, i.e., \? \+ \| are not recognized. Actually, this
|
||||
isn't minimal, since other operators, such as \`, aren't disabled. */
|
||||
#define RE_SYNTAX_POSIX_MINIMAL_BASIC \
|
||||
(_RE_SYNTAX_POSIX_COMMON | RE_LIMITED_OPS)
|
||||
|
||||
#define RE_SYNTAX_POSIX_EXTENDED \
|
||||
(_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \
|
||||
| RE_CONTEXT_INDEP_OPS | RE_NO_BK_BRACES \
|
||||
| RE_NO_BK_PARENS | RE_NO_BK_VBAR \
|
||||
| RE_CONTEXT_INVALID_OPS | RE_UNMATCHED_RIGHT_PAREN_ORD)
|
||||
|
||||
/* Differs from ..._POSIX_EXTENDED in that RE_CONTEXT_INDEP_OPS is
|
||||
removed and RE_NO_BK_REFS is added. */
|
||||
#define RE_SYNTAX_POSIX_MINIMAL_EXTENDED \
|
||||
(_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \
|
||||
| RE_CONTEXT_INVALID_OPS | RE_NO_BK_BRACES \
|
||||
| RE_NO_BK_PARENS | RE_NO_BK_REFS \
|
||||
| RE_NO_BK_VBAR | RE_UNMATCHED_RIGHT_PAREN_ORD)
|
||||
/* [[[end syntaxes]]] */
|
||||
|
||||
/* Maximum number of duplicates an interval can allow. Some systems
|
||||
(erroneously) define this in other header files, but we want our
|
||||
value, so remove any previous define. */
|
||||
#ifdef RE_DUP_MAX
|
||||
# undef RE_DUP_MAX
|
||||
#endif
|
||||
/* If sizeof(int) == 2, then ((1 << 15) - 1) overflows. */
|
||||
#define RE_DUP_MAX (0x7fff)
|
||||
|
||||
|
||||
/* POSIX `cflags' bits (i.e., information for `regcomp'). */
|
||||
|
||||
/* If this bit is set, then use extended regular expression syntax.
|
||||
If not set, then use basic regular expression syntax. */
|
||||
#define REG_EXTENDED 1
|
||||
|
||||
/* If this bit is set, then ignore case when matching.
|
||||
If not set, then case is significant. */
|
||||
#define REG_ICASE (REG_EXTENDED << 1)
|
||||
|
||||
/* If this bit is set, then anchors do not match at newline
|
||||
characters in the string.
|
||||
If not set, then anchors do match at newlines. */
|
||||
#define REG_NEWLINE (REG_ICASE << 1)
|
||||
|
||||
/* If this bit is set, then report only success or fail in regexec.
|
||||
If not set, then returns differ between not matching and errors. */
|
||||
#define REG_NOSUB (REG_NEWLINE << 1)
|
||||
|
||||
|
||||
/* POSIX `eflags' bits (i.e., information for regexec). */
|
||||
|
||||
/* If this bit is set, then the beginning-of-line operator doesn't match
|
||||
the beginning of the string (presumably because it's not the
|
||||
beginning of a line).
|
||||
If not set, then the beginning-of-line operator does match the
|
||||
beginning of the string. */
|
||||
#define REG_NOTBOL 1
|
||||
|
||||
/* Like REG_NOTBOL, except for the end-of-line. */
|
||||
#define REG_NOTEOL (1 << 1)
|
||||
|
||||
/* Use pmatch[0] to set boundaries for regexec. */
|
||||
#define REG_STARTEND (1 << 2)
|
||||
|
||||
|
||||
/* If any error codes are removed, changed, or added, update the
|
||||
`re_error_msg' table in regex.c. */
|
||||
typedef enum
|
||||
{
|
||||
#ifdef _XOPEN_SOURCE
|
||||
REG_ENOSYS = -1, /* This will never happen for this implementation. */
|
||||
#endif
|
||||
|
||||
REG_NOERROR = 0, /* Success. */
|
||||
REG_NOMATCH, /* Didn't find a match (for regexec). */
|
||||
|
||||
/* POSIX regcomp return error codes. (In the order listed in the
|
||||
standard.) */
|
||||
REG_BADPAT, /* Invalid pattern. */
|
||||
REG_ECOLLATE, /* Inalid collating element. */
|
||||
REG_ECTYPE, /* Invalid character class name. */
|
||||
REG_EESCAPE, /* Trailing backslash. */
|
||||
REG_ESUBREG, /* Invalid back reference. */
|
||||
REG_EBRACK, /* Unmatched left bracket. */
|
||||
REG_EPAREN, /* Parenthesis imbalance. */
|
||||
REG_EBRACE, /* Unmatched \{. */
|
||||
REG_BADBR, /* Invalid contents of \{\}. */
|
||||
REG_ERANGE, /* Invalid range end. */
|
||||
REG_ESPACE, /* Ran out of memory. */
|
||||
REG_BADRPT, /* No preceding re for repetition op. */
|
||||
|
||||
/* Error codes we've added. */
|
||||
REG_EEND, /* Premature end. */
|
||||
REG_ESIZE, /* Compiled pattern bigger than 2^16 bytes. */
|
||||
REG_ERPAREN /* Unmatched ) or \); not returned from regcomp. */
|
||||
} reg_errcode_t;
|
||||
|
||||
/* This data structure represents a compiled pattern. Before calling
|
||||
the pattern compiler, the fields `buffer', `allocated', `fastmap',
|
||||
`translate', and `no_sub' can be set. After the pattern has been
|
||||
compiled, the `re_nsub' field is available. All other fields are
|
||||
private to the regex routines. */
|
||||
|
||||
#ifndef RE_TRANSLATE_TYPE
|
||||
# define RE_TRANSLATE_TYPE char *
|
||||
#endif
|
||||
|
||||
struct re_pattern_buffer
|
||||
{
|
||||
/* [[[begin pattern_buffer]]] */
|
||||
/* Space that holds the compiled pattern. It is declared as
|
||||
`unsigned char *' because its elements are
|
||||
sometimes used as array indexes. */
|
||||
unsigned char *buffer;
|
||||
|
||||
/* Number of bytes to which `buffer' points. */
|
||||
unsigned long int allocated;
|
||||
|
||||
/* Number of bytes actually used in `buffer'. */
|
||||
unsigned long int used;
|
||||
|
||||
/* Syntax setting with which the pattern was compiled. */
|
||||
reg_syntax_t syntax;
|
||||
|
||||
/* Pointer to a fastmap, if any, otherwise zero. re_search uses
|
||||
the fastmap, if there is one, to skip over impossible
|
||||
starting points for matches. */
|
||||
char *fastmap;
|
||||
|
||||
/* Either a translate table to apply to all characters before
|
||||
comparing them, or zero for no translation. The translation
|
||||
is applied to a pattern when it is compiled and to a string
|
||||
when it is matched. */
|
||||
RE_TRANSLATE_TYPE translate;
|
||||
|
||||
/* Number of subexpressions found by the compiler. */
|
||||
size_t re_nsub;
|
||||
|
||||
/* Zero if this pattern cannot match the empty string, one else.
|
||||
Well, in truth it's used only in `re_search_2', to see
|
||||
whether or not we should use the fastmap, so we don't set
|
||||
this absolutely perfectly; see `re_compile_fastmap' (the
|
||||
`duplicate' case). */
|
||||
unsigned can_be_null : 1;
|
||||
|
||||
/* If REGS_UNALLOCATED, allocate space in the `regs' structure
|
||||
for `max (RE_NREGS, re_nsub + 1)' groups.
|
||||
If REGS_REALLOCATE, reallocate space if necessary.
|
||||
If REGS_FIXED, use what's there. */
|
||||
#define REGS_UNALLOCATED 0
|
||||
#define REGS_REALLOCATE 1
|
||||
#define REGS_FIXED 2
|
||||
unsigned regs_allocated : 2;
|
||||
|
||||
/* Set to zero when `regex_compile' compiles a pattern; set to one
|
||||
by `re_compile_fastmap' if it updates the fastmap. */
|
||||
unsigned fastmap_accurate : 1;
|
||||
|
||||
/* If set, `re_match_2' does not return information about
|
||||
subexpressions. */
|
||||
unsigned no_sub : 1;
|
||||
|
||||
/* If set, a beginning-of-line anchor doesn't match at the
|
||||
beginning of the string. */
|
||||
unsigned not_bol : 1;
|
||||
|
||||
/* Similarly for an end-of-line anchor. */
|
||||
unsigned not_eol : 1;
|
||||
|
||||
/* If true, an anchor at a newline matches. */
|
||||
unsigned newline_anchor : 1;
|
||||
|
||||
/* [[[end pattern_buffer]]] */
|
||||
};
|
||||
|
||||
typedef struct re_pattern_buffer regex_t;
|
||||
|
||||
/* Type for byte offsets within the string. POSIX mandates this. */
|
||||
typedef int regoff_t;
|
||||
|
||||
|
||||
/* This is the structure we store register match data in. See
|
||||
regex.texinfo for a full description of what registers match. */
|
||||
struct re_registers
|
||||
{
|
||||
unsigned num_regs;
|
||||
regoff_t *start;
|
||||
regoff_t *end;
|
||||
};
|
||||
|
||||
|
||||
/* If `regs_allocated' is REGS_UNALLOCATED in the pattern buffer,
|
||||
`re_match_2' returns information about at least this many registers
|
||||
the first time a `regs' structure is passed. */
|
||||
#ifndef RE_NREGS
|
||||
# define RE_NREGS 30
|
||||
#endif
|
||||
|
||||
|
||||
/* POSIX specification for registers. Aside from the different names than
|
||||
`re_registers', POSIX uses an array of structures, instead of a
|
||||
structure of arrays. */
|
||||
typedef struct
|
||||
{
|
||||
regoff_t rm_so; /* Byte offset from string's start to substring's start. */
|
||||
regoff_t rm_eo; /* Byte offset from string's start to substring's end. */
|
||||
} regmatch_t;
|
||||
|
||||
/* Declarations for routines. */
|
||||
|
||||
/* To avoid duplicating every routine declaration -- once with a
|
||||
prototype (if we are ANSI), and once without (if we aren't) -- we
|
||||
use the following macro to declare argument types. This
|
||||
unfortunately clutters up the declarations a bit, but I think it's
|
||||
worth it. */
|
||||
|
||||
#if __STDC__
|
||||
|
||||
# define _RE_ARGS(args) args
|
||||
|
||||
#else /* not __STDC__ */
|
||||
|
||||
# define _RE_ARGS(args) ()
|
||||
|
||||
#endif /* not __STDC__ */
|
||||
|
||||
/* Sets the current default syntax to SYNTAX, and return the old syntax.
|
||||
You can also simply assign to the `re_syntax_options' variable. */
|
||||
extern reg_syntax_t re_set_syntax _RE_ARGS ((reg_syntax_t syntax));
|
||||
|
||||
/* Compile the regular expression PATTERN, with length LENGTH
|
||||
and syntax given by the global `re_syntax_options', into the buffer
|
||||
BUFFER. Return NULL if successful, and an error string if not. */
|
||||
extern const char *re_compile_pattern
|
||||
_RE_ARGS ((const char *pattern, size_t length,
|
||||
struct re_pattern_buffer *buffer));
|
||||
|
||||
|
||||
/* Compile a fastmap for the compiled pattern in BUFFER; used to
|
||||
accelerate searches. Return 0 if successful and -2 if was an
|
||||
internal error. */
|
||||
extern int re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer));
|
||||
|
||||
|
||||
/* Search in the string STRING (with length LENGTH) for the pattern
|
||||
compiled into BUFFER. Start searching at position START, for RANGE
|
||||
characters. Return the starting position of the match, -1 for no
|
||||
match, or -2 for an internal error. Also return register
|
||||
information in REGS (if REGS and BUFFER->no_sub are nonzero). */
|
||||
extern int re_search
|
||||
_RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
|
||||
int length, int start, int range, struct re_registers *regs));
|
||||
|
||||
|
||||
/* Like `re_search', but search in the concatenation of STRING1 and
|
||||
STRING2. Also, stop searching at index START + STOP. */
|
||||
extern int re_search_2
|
||||
_RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
|
||||
int length1, const char *string2, int length2,
|
||||
int start, int range, struct re_registers *regs, int stop));
|
||||
|
||||
|
||||
/* Like `re_search', but return how many characters in STRING the regexp
|
||||
in BUFFER matched, starting at position START. */
|
||||
extern int re_match
|
||||
_RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
|
||||
int length, int start, struct re_registers *regs));
|
||||
|
||||
|
||||
/* Relates to `re_match' as `re_search_2' relates to `re_search'. */
|
||||
extern int re_match_2
|
||||
_RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
|
||||
int length1, const char *string2, int length2,
|
||||
int start, struct re_registers *regs, int stop));
|
||||
|
||||
|
||||
/* Set REGS to hold NUM_REGS registers, storing them in STARTS and
|
||||
ENDS. Subsequent matches using BUFFER and REGS will use this memory
|
||||
for recording register information. STARTS and ENDS must be
|
||||
allocated with malloc, and must each be at least `NUM_REGS * sizeof
|
||||
(regoff_t)' bytes long.
|
||||
|
||||
If NUM_REGS == 0, then subsequent matches should allocate their own
|
||||
register data.
|
||||
|
||||
Unless this function is called, the first search or match using
|
||||
PATTERN_BUFFER will allocate its own register data, without
|
||||
freeing the old data. */
|
||||
extern void re_set_registers
|
||||
_RE_ARGS ((struct re_pattern_buffer *buffer, struct re_registers *regs,
|
||||
unsigned num_regs, regoff_t *starts, regoff_t *ends));
|
||||
|
||||
#if defined _REGEX_RE_COMP || defined _LIBC
|
||||
# ifndef _CRAY
|
||||
/* 4.2 bsd compatibility. */
|
||||
extern char *re_comp _RE_ARGS ((const char *));
|
||||
extern int re_exec _RE_ARGS ((const char *));
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* GCC 2.95 and later have "__restrict"; C99 compilers have
|
||||
"restrict", and "configure" may have defined "restrict". */
|
||||
#ifndef __restrict
|
||||
# if ! (2 < __GNUC__ || (2 == __GNUC__ && 95 <= __GNUC_MINOR__))
|
||||
# if defined restrict || 199901L <= __STDC_VERSION__
|
||||
# define __restrict restrict
|
||||
# else
|
||||
# define __restrict
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
/* gcc 3.1 and up support the [restrict] syntax. */
|
||||
#ifndef __restrict_arr
|
||||
# if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)
|
||||
# define __restrict_arr __restrict
|
||||
# else
|
||||
# define __restrict_arr
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* POSIX compatibility. */
|
||||
extern int regcomp _RE_ARGS ((regex_t *__restrict __preg,
|
||||
const char *__restrict __pattern,
|
||||
int __cflags));
|
||||
|
||||
extern int regexec _RE_ARGS ((const regex_t *__restrict __preg,
|
||||
const char *__restrict __string, size_t __nmatch,
|
||||
regmatch_t __pmatch[__restrict_arr],
|
||||
int __eflags));
|
||||
|
||||
extern size_t regerror _RE_ARGS ((int __errcode, const regex_t *__preg,
|
||||
char *__errbuf, size_t __errbuf_size));
|
||||
|
||||
extern void regfree _RE_ARGS ((regex_t *__preg));
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* C++ */
|
||||
|
||||
#endif /* regex.h */
|
||||
|
||||
/*
|
||||
Local variables:
|
||||
make-backup-files: t
|
||||
version-control: t
|
||||
trim-versions-without-asking: nil
|
||||
End:
|
||||
*/
|
||||
File diff suppressed because it is too large.
Load diff
@@ -1,807 +0,0 @@
|
||||
/* Extended regular expression matching and search library.
|
||||
Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
Contributed by Isamu Hasegawa <isamu@yamato.ibm.com>.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
The GNU C Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with the GNU C Library; if not, write to the Free
|
||||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA. */
|
||||
|
||||
#ifndef _REGEX_INTERNAL_H
|
||||
#define _REGEX_INTERNAL_H 1
|
||||
|
||||
#include <assert.h>
|
||||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#if defined HAVE_LOCALE_H || defined _LIBC
|
||||
# include <locale.h>
|
||||
#endif
|
||||
#if defined HAVE_WCHAR_H || defined _LIBC
|
||||
# include <wchar.h>
|
||||
#endif /* HAVE_WCHAR_H || _LIBC */
|
||||
#if defined HAVE_WCTYPE_H || defined _LIBC
|
||||
# include <wctype.h>
|
||||
#endif /* HAVE_WCTYPE_H || _LIBC */
|
||||
|
||||
/* In case that the system doesn't have isblank(). */
|
||||
#if !defined _LIBC && !defined HAVE_ISBLANK && !defined isblank
|
||||
# define isblank(ch) ((ch) == ' ' || (ch) == '\t')
|
||||
#endif
|
||||
|
||||
#ifdef _LIBC
|
||||
# ifndef _RE_DEFINE_LOCALE_FUNCTIONS
|
||||
# define _RE_DEFINE_LOCALE_FUNCTIONS 1
|
||||
# include <locale/localeinfo.h>
|
||||
# include <locale/elem-hash.h>
|
||||
# include <locale/coll-lookup.h>
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* This is for other GNU distributions with internationalized messages. */
|
||||
#if (HAVE_LIBINTL_H && ENABLE_NLS) || defined _LIBC
|
||||
# include <libintl.h>
|
||||
# ifdef _LIBC
|
||||
# undef gettext
|
||||
# define gettext(msgid) \
|
||||
INTUSE(__dcgettext) (INTUSE(_libc_intl_domainname), msgid, LC_MESSAGES)
|
||||
# endif
|
||||
#else
|
||||
# define gettext(msgid) (msgid)
|
||||
#endif
|
||||
|
||||
#ifndef gettext_noop
|
||||
/* This define is so xgettext can find the internationalizable
|
||||
strings. */
|
||||
# define gettext_noop(String) String
|
||||
#endif
|
||||
|
||||
#if (defined MB_CUR_MAX && HAVE_LOCALE_H && HAVE_WCTYPE_H && HAVE_WCHAR_H && HAVE_WCRTOMB && HAVE_MBRTOWC && HAVE_WCSCOLL) || _LIBC
|
||||
# define RE_ENABLE_I18N
|
||||
#endif
|
||||
|
||||
#if __GNUC__ >= 3
|
||||
# define BE(expr, val) __builtin_expect (expr, val)
|
||||
#else
|
||||
# define BE(expr, val) (expr)
|
||||
# define inline
|
||||
#endif
|
||||
|
||||
/* Number of bits in a byte. */
|
||||
#define BYTE_BITS 8
|
||||
/* Number of single byte character. */
|
||||
#define SBC_MAX 256
|
||||
|
||||
#define COLL_ELEM_LEN_MAX 8
|
||||
|
||||
/* The character which represents newline. */
|
||||
#define NEWLINE_CHAR '\n'
|
||||
#define WIDE_NEWLINE_CHAR L'\n'
|
||||
|
||||
/* Rename to standard API for using out of glibc. */
|
||||
#ifndef _LIBC
|
||||
# define __wctype wctype
|
||||
# define __iswctype iswctype
|
||||
# define __btowc btowc
|
||||
/* This one is defined by string2.h */
|
||||
# ifndef __mempcpy
|
||||
# define __mempcpy mempcpy
|
||||
# endif
|
||||
# define __wcrtomb wcrtomb
|
||||
# define attribute_hidden
|
||||
#endif /* not _LIBC */
|
||||
|
||||
#ifdef __GNUC__
|
||||
# define __attribute(arg) __attribute__ (arg)
|
||||
#else
|
||||
# define __attribute(arg)
|
||||
#endif
|
||||
|
||||
extern const char __re_error_msgid[] attribute_hidden;
|
||||
extern const size_t __re_error_msgid_idx[] attribute_hidden;
|
||||
|
||||
/* Number of bits in an unsinged int. */
|
||||
#define UINT_BITS (sizeof (unsigned int) * BYTE_BITS)
|
||||
/* Number of unsigned int in an bit_set. */
|
||||
#define BITSET_UINTS ((SBC_MAX + UINT_BITS - 1) / UINT_BITS)
|
||||
typedef unsigned int bitset[BITSET_UINTS];
|
||||
typedef unsigned int *re_bitset_ptr_t;
|
||||
typedef const unsigned int *re_const_bitset_ptr_t;
|
||||
|
||||
#define bitset_set(set,i) (set[i / UINT_BITS] |= 1 << i % UINT_BITS)
|
||||
#define bitset_clear(set,i) (set[i / UINT_BITS] &= ~(1 << i % UINT_BITS))
|
||||
#define bitset_contain(set,i) (set[i / UINT_BITS] & (1 << i % UINT_BITS))
|
||||
#define bitset_empty(set) memset (set, 0, sizeof (unsigned int) * BITSET_UINTS)
|
||||
#define bitset_set_all(set) \
|
||||
memset (set, 255, sizeof (unsigned int) * BITSET_UINTS)
|
||||
#define bitset_copy(dest,src) \
|
||||
memcpy (dest, src, sizeof (unsigned int) * BITSET_UINTS)
|
||||
static inline void bitset_not (bitset set);
|
||||
static inline void bitset_merge (bitset dest, const bitset src);
|
||||
static inline void bitset_not_merge (bitset dest, const bitset src);
|
||||
static inline void bitset_mask (bitset dest, const bitset src);
|
||||
|
||||
#define PREV_WORD_CONSTRAINT 0x0001
|
||||
#define PREV_NOTWORD_CONSTRAINT 0x0002
|
||||
#define NEXT_WORD_CONSTRAINT 0x0004
|
||||
#define NEXT_NOTWORD_CONSTRAINT 0x0008
|
||||
#define PREV_NEWLINE_CONSTRAINT 0x0010
|
||||
#define NEXT_NEWLINE_CONSTRAINT 0x0020
|
||||
#define PREV_BEGBUF_CONSTRAINT 0x0040
|
||||
#define NEXT_ENDBUF_CONSTRAINT 0x0080
|
||||
#define DUMMY_CONSTRAINT 0x0100
|
||||
|
||||
typedef enum
|
||||
{
|
||||
INSIDE_WORD = PREV_WORD_CONSTRAINT | NEXT_WORD_CONSTRAINT,
|
||||
WORD_FIRST = PREV_NOTWORD_CONSTRAINT | NEXT_WORD_CONSTRAINT,
|
||||
WORD_LAST = PREV_WORD_CONSTRAINT | NEXT_NOTWORD_CONSTRAINT,
|
||||
LINE_FIRST = PREV_NEWLINE_CONSTRAINT,
|
||||
LINE_LAST = NEXT_NEWLINE_CONSTRAINT,
|
||||
BUF_FIRST = PREV_BEGBUF_CONSTRAINT,
|
||||
BUF_LAST = NEXT_ENDBUF_CONSTRAINT,
|
||||
WORD_DELIM = DUMMY_CONSTRAINT
|
||||
} re_context_type;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int alloc;
|
||||
int nelem;
|
||||
int *elems;
|
||||
} re_node_set;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
NON_TYPE = 0,
|
||||
|
||||
/* Node type, These are used by token, node, tree. */
|
||||
CHARACTER = 1,
|
||||
END_OF_RE = 2,
|
||||
SIMPLE_BRACKET = 3,
|
||||
OP_BACK_REF = 4,
|
||||
OP_PERIOD = 5,
|
||||
#ifdef RE_ENABLE_I18N
|
||||
COMPLEX_BRACKET = 6,
|
||||
OP_UTF8_PERIOD = 7,
|
||||
#endif /* RE_ENABLE_I18N */
|
||||
|
||||
/* We define EPSILON_BIT as a macro so that OP_OPEN_SUBEXP is used
|
||||
when the debugger shows values of this enum type. */
|
||||
#define EPSILON_BIT 8
|
||||
OP_OPEN_SUBEXP = EPSILON_BIT | 0,
|
||||
OP_CLOSE_SUBEXP = EPSILON_BIT | 1,
|
||||
OP_ALT = EPSILON_BIT | 2,
|
||||
OP_DUP_ASTERISK = EPSILON_BIT | 3,
|
||||
OP_DUP_PLUS = EPSILON_BIT | 4,
|
||||
OP_DUP_QUESTION = EPSILON_BIT | 5,
|
||||
ANCHOR = EPSILON_BIT | 6,
|
||||
|
||||
/* Tree type, these are used only by tree. */
|
||||
CONCAT = 16,
|
||||
|
||||
/* Token type, these are used only by token. */
|
||||
OP_OPEN_BRACKET = 17,
|
||||
OP_CLOSE_BRACKET,
|
||||
OP_CHARSET_RANGE,
|
||||
OP_OPEN_DUP_NUM,
|
||||
OP_CLOSE_DUP_NUM,
|
||||
OP_NON_MATCH_LIST,
|
||||
OP_OPEN_COLL_ELEM,
|
||||
OP_CLOSE_COLL_ELEM,
|
||||
OP_OPEN_EQUIV_CLASS,
|
||||
OP_CLOSE_EQUIV_CLASS,
|
||||
OP_OPEN_CHAR_CLASS,
|
||||
OP_CLOSE_CHAR_CLASS,
|
||||
OP_WORD,
|
||||
OP_NOTWORD,
|
||||
OP_SPACE,
|
||||
OP_NOTSPACE,
|
||||
BACK_SLASH
|
||||
|
||||
} re_token_type_t;
|
||||
|
||||
#ifdef RE_ENABLE_I18N
|
||||
typedef struct
|
||||
{
|
||||
/* Multibyte characters. */
|
||||
wchar_t *mbchars;
|
||||
|
||||
/* Collating symbols. */
|
||||
# ifdef _LIBC
|
||||
int32_t *coll_syms;
|
||||
# endif
|
||||
|
||||
/* Equivalence classes. */
|
||||
# ifdef _LIBC
|
||||
int32_t *equiv_classes;
|
||||
# endif
|
||||
|
||||
/* Range expressions. */
|
||||
# ifdef _LIBC
|
||||
uint32_t *range_starts;
|
||||
uint32_t *range_ends;
|
||||
# else /* not _LIBC */
|
||||
wchar_t *range_starts;
|
||||
wchar_t *range_ends;
|
||||
# endif /* not _LIBC */
|
||||
|
||||
/* Character classes. */
|
||||
wctype_t *char_classes;
|
||||
|
||||
/* If this character set is the non-matching list. */
|
||||
unsigned int non_match : 1;
|
||||
|
||||
/* # of multibyte characters. */
|
||||
int nmbchars;
|
||||
|
||||
/* # of collating symbols. */
|
||||
int ncoll_syms;
|
||||
|
||||
/* # of equivalence classes. */
|
||||
int nequiv_classes;
|
||||
|
||||
/* # of range expressions. */
|
||||
int nranges;
|
||||
|
||||
/* # of character classes. */
|
||||
int nchar_classes;
|
||||
} re_charset_t;
|
||||
#endif /* RE_ENABLE_I18N */
|
||||
|
||||
typedef struct
|
||||
{
|
||||
union
|
||||
{
|
||||
unsigned char c; /* for CHARACTER */
|
||||
re_bitset_ptr_t sbcset; /* for SIMPLE_BRACKET */
|
||||
#ifdef RE_ENABLE_I18N
|
||||
re_charset_t *mbcset; /* for COMPLEX_BRACKET */
|
||||
#endif /* RE_ENABLE_I18N */
|
||||
int idx; /* for BACK_REF */
|
||||
re_context_type ctx_type; /* for ANCHOR */
|
||||
} opr;
|
||||
#if __GNUC__ >= 2
|
||||
re_token_type_t type : 8;
|
||||
#else
|
||||
re_token_type_t type;
|
||||
#endif
|
||||
unsigned int constraint : 10; /* context constraint */
|
||||
unsigned int duplicated : 1;
|
||||
unsigned int opt_subexp : 1;
|
||||
#ifdef RE_ENABLE_I18N
|
||||
/* These 2 bits can be moved into the union if needed (e.g. if running out
|
||||
of bits; move opr.c to opr.c.c and move the flags to opr.c.flags). */
|
||||
unsigned int mb_partial : 1;
|
||||
#endif
|
||||
unsigned int word_char : 1;
|
||||
} re_token_t;
|
||||
|
||||
#define IS_EPSILON_NODE(type) ((type) & EPSILON_BIT)
|
||||
#define ACCEPT_MB_NODE(type) \
|
||||
((type) >= OP_PERIOD && (type) <= OP_UTF8_PERIOD)
|
||||
|
||||
struct re_string_t
|
||||
{
|
||||
/* Indicate the raw buffer which is the original string passed as an
|
||||
argument of regexec(), re_search(), etc.. */
|
||||
const unsigned char *raw_mbs;
|
||||
/* Store the multibyte string. In case of "case insensitive mode" like
|
||||
REG_ICASE, upper cases of the string are stored, otherwise MBS points
|
||||
the same address that RAW_MBS points. */
|
||||
unsigned char *mbs;
|
||||
#ifdef RE_ENABLE_I18N
|
||||
/* Store the wide character string which is corresponding to MBS. */
|
||||
wint_t *wcs;
|
||||
int *offsets;
|
||||
mbstate_t cur_state;
|
||||
#endif
|
||||
/* Index in RAW_MBS. Each character mbs[i] corresponds to
|
||||
raw_mbs[raw_mbs_idx + i]. */
|
||||
int raw_mbs_idx;
|
||||
/* The length of the valid characters in the buffers. */
|
||||
int valid_len;
|
||||
/* The corresponding number of bytes in raw_mbs array. */
|
||||
int valid_raw_len;
|
||||
/* The length of the buffers MBS and WCS. */
|
||||
int bufs_len;
|
||||
/* The index in MBS, which is updated by re_string_fetch_byte. */
|
||||
int cur_idx;
|
||||
/* length of RAW_MBS array. */
|
||||
int raw_len;
|
||||
/* This is RAW_LEN - RAW_MBS_IDX + VALID_LEN - VALID_RAW_LEN. */
|
||||
int len;
|
||||
/* End of the buffer may be shorter than its length in the cases such
|
||||
as re_match_2, re_search_2. Then, we use STOP for end of the buffer
|
||||
instead of LEN. */
|
||||
int raw_stop;
|
||||
/* This is RAW_STOP - RAW_MBS_IDX adjusted through OFFSETS. */
|
||||
int stop;
|
||||
|
||||
/* The context of mbs[0]. We store the context independently, since
|
||||
the context of mbs[0] may be different from raw_mbs[0], which is
|
||||
the beginning of the input string. */
|
||||
unsigned int tip_context;
|
||||
/* The translation passed as a part of an argument of re_compile_pattern. */
|
||||
unsigned RE_TRANSLATE_TYPE trans;
|
||||
/* Copy of re_dfa_t's word_char. */
|
||||
re_const_bitset_ptr_t word_char;
|
||||
/* 1 if REG_ICASE. */
|
||||
unsigned char icase;
|
||||
unsigned char is_utf8;
|
||||
unsigned char map_notascii;
|
||||
unsigned char mbs_allocated;
|
||||
unsigned char offsets_needed;
|
||||
unsigned char newline_anchor;
|
||||
unsigned char word_ops_used;
|
||||
int mb_cur_max;
|
||||
};
|
||||
typedef struct re_string_t re_string_t;
|
||||
|
||||
|
||||
struct re_dfa_t;
|
||||
typedef struct re_dfa_t re_dfa_t;
|
||||
|
||||
#ifndef _LIBC
|
||||
# ifdef __i386__
|
||||
# define internal_function __attribute ((regparm (3), stdcall))
|
||||
# else
|
||||
# define internal_function
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef RE_NO_INTERNAL_PROTOTYPES
|
||||
static reg_errcode_t re_string_allocate (re_string_t *pstr, const char *str,
|
||||
int len, int init_len,
|
||||
RE_TRANSLATE_TYPE trans, int icase,
|
||||
const re_dfa_t *dfa)
|
||||
internal_function;
|
||||
static reg_errcode_t re_string_construct (re_string_t *pstr, const char *str,
|
||||
int len, RE_TRANSLATE_TYPE trans,
|
||||
int icase, const re_dfa_t *dfa)
|
||||
internal_function;
|
||||
static reg_errcode_t re_string_reconstruct (re_string_t *pstr, int idx,
|
||||
int eflags) internal_function;
|
||||
static reg_errcode_t re_string_realloc_buffers (re_string_t *pstr,
|
||||
int new_buf_len)
|
||||
internal_function;
|
||||
# ifdef RE_ENABLE_I18N
|
||||
static void build_wcs_buffer (re_string_t *pstr) internal_function;
|
||||
static int build_wcs_upper_buffer (re_string_t *pstr) internal_function;
|
||||
# endif /* RE_ENABLE_I18N */
|
||||
static void build_upper_buffer (re_string_t *pstr) internal_function;
|
||||
static void re_string_translate_buffer (re_string_t *pstr) internal_function;
|
||||
static void re_string_destruct (re_string_t *pstr) internal_function;
|
||||
# ifdef RE_ENABLE_I18N
|
||||
static int re_string_elem_size_at (const re_string_t *pstr, int idx)
|
||||
internal_function;
|
||||
static inline int re_string_char_size_at (const re_string_t *pstr, int idx)
|
||||
internal_function;
|
||||
static inline wint_t re_string_wchar_at (const re_string_t *pstr, int idx)
|
||||
internal_function;
|
||||
# endif /* RE_ENABLE_I18N */
|
||||
static unsigned int re_string_context_at (const re_string_t *input, int idx,
|
||||
int eflags) internal_function;
|
||||
static unsigned char re_string_peek_byte_case (const re_string_t *pstr,
|
||||
int idx) internal_function;
|
||||
static unsigned char re_string_fetch_byte_case (re_string_t *pstr)
|
||||
internal_function;
|
||||
#endif
|
||||
#define re_string_peek_byte(pstr, offset) \
|
||||
((pstr)->mbs[(pstr)->cur_idx + offset])
|
||||
#define re_string_fetch_byte(pstr) \
|
||||
((pstr)->mbs[(pstr)->cur_idx++])
|
||||
#define re_string_first_byte(pstr, idx) \
|
||||
((idx) == (pstr)->valid_len || (pstr)->wcs[idx] != WEOF)
|
||||
#define re_string_is_single_byte_char(pstr, idx) \
|
||||
((pstr)->wcs[idx] != WEOF && ((pstr)->valid_len == (idx) + 1 \
|
||||
|| (pstr)->wcs[(idx) + 1] != WEOF))
|
||||
#define re_string_eoi(pstr) ((pstr)->stop <= (pstr)->cur_idx)
|
||||
#define re_string_cur_idx(pstr) ((pstr)->cur_idx)
|
||||
#define re_string_get_buffer(pstr) ((pstr)->mbs)
|
||||
#define re_string_length(pstr) ((pstr)->len)
|
||||
#define re_string_byte_at(pstr,idx) ((pstr)->mbs[idx])
|
||||
#define re_string_skip_bytes(pstr,idx) ((pstr)->cur_idx += (idx))
|
||||
#define re_string_set_index(pstr,idx) ((pstr)->cur_idx = (idx))
|
||||
|
||||
#define re_malloc(t,n) ((t *) malloc ((n) * sizeof (t)))
|
||||
#define re_realloc(p,t,n) ((t *) realloc (p, (n) * sizeof (t)))
|
||||
#define re_free(p) free (p)
|
||||
|
||||
struct bin_tree_t
|
||||
{
|
||||
struct bin_tree_t *parent;
|
||||
struct bin_tree_t *left;
|
||||
struct bin_tree_t *right;
|
||||
|
||||
/* `node_idx' is the index in dfa->nodes, if `type' == 0.
|
||||
Otherwise `type' indicate the type of this node. */
|
||||
re_token_type_t type;
|
||||
int node_idx;
|
||||
|
||||
int first;
|
||||
int next;
|
||||
re_node_set eclosure;
|
||||
};
|
||||
typedef struct bin_tree_t bin_tree_t;
|
||||
|
||||
#define BIN_TREE_STORAGE_SIZE \
|
||||
((1024 - sizeof (void *)) / sizeof (bin_tree_t))
|
||||
|
||||
struct bin_tree_storage_t
|
||||
{
|
||||
struct bin_tree_storage_t *next;
|
||||
bin_tree_t data[BIN_TREE_STORAGE_SIZE];
|
||||
};
|
||||
typedef struct bin_tree_storage_t bin_tree_storage_t;
|
||||
|
||||
#define CONTEXT_WORD 1
|
||||
#define CONTEXT_NEWLINE (CONTEXT_WORD << 1)
|
||||
#define CONTEXT_BEGBUF (CONTEXT_NEWLINE << 1)
|
||||
#define CONTEXT_ENDBUF (CONTEXT_BEGBUF << 1)
|
||||
|
||||
#define IS_WORD_CONTEXT(c) ((c) & CONTEXT_WORD)
|
||||
#define IS_NEWLINE_CONTEXT(c) ((c) & CONTEXT_NEWLINE)
|
||||
#define IS_BEGBUF_CONTEXT(c) ((c) & CONTEXT_BEGBUF)
|
||||
#define IS_ENDBUF_CONTEXT(c) ((c) & CONTEXT_ENDBUF)
|
||||
#define IS_ORDINARY_CONTEXT(c) ((c) == 0)
|
||||
|
||||
#define IS_WORD_CHAR(ch) (isalnum (ch) || (ch) == '_')
|
||||
#define IS_NEWLINE(ch) ((ch) == NEWLINE_CHAR)
|
||||
#define IS_WIDE_WORD_CHAR(ch) (iswalnum (ch) || (ch) == L'_')
|
||||
#define IS_WIDE_NEWLINE(ch) ((ch) == WIDE_NEWLINE_CHAR)
|
||||
|
||||
#define NOT_SATISFY_PREV_CONSTRAINT(constraint,context) \
|
||||
((((constraint) & PREV_WORD_CONSTRAINT) && !IS_WORD_CONTEXT (context)) \
|
||||
|| ((constraint & PREV_NOTWORD_CONSTRAINT) && IS_WORD_CONTEXT (context)) \
|
||||
|| ((constraint & PREV_NEWLINE_CONSTRAINT) && !IS_NEWLINE_CONTEXT (context))\
|
||||
|| ((constraint & PREV_BEGBUF_CONSTRAINT) && !IS_BEGBUF_CONTEXT (context)))
|
||||
|
||||
#define NOT_SATISFY_NEXT_CONSTRAINT(constraint,context) \
|
||||
((((constraint) & NEXT_WORD_CONSTRAINT) && !IS_WORD_CONTEXT (context)) \
|
||||
|| (((constraint) & NEXT_NOTWORD_CONSTRAINT) && IS_WORD_CONTEXT (context)) \
|
||||
|| (((constraint) & NEXT_NEWLINE_CONSTRAINT) && !IS_NEWLINE_CONTEXT (context)) \
|
||||
|| (((constraint) & NEXT_ENDBUF_CONSTRAINT) && !IS_ENDBUF_CONTEXT (context)))
|
||||
|
||||
struct re_dfastate_t
|
||||
{
|
||||
unsigned int hash;
|
||||
re_node_set nodes;
|
||||
re_node_set *entrance_nodes;
|
||||
struct re_dfastate_t **trtable;
|
||||
struct re_dfastate_t **word_trtable;
|
||||
unsigned int context : 4;
|
||||
unsigned int halt : 1;
|
||||
/* If this state can accept `multi byte'.
|
||||
Note that we refer to multibyte characters, and multi character
|
||||
collating elements as `multi byte'. */
|
||||
unsigned int accept_mb : 1;
|
||||
/* If this state has backreference node(s). */
|
||||
unsigned int has_backref : 1;
|
||||
unsigned int has_constraint : 1;
|
||||
};
|
||||
typedef struct re_dfastate_t re_dfastate_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
/* start <= node < end */
|
||||
int start;
|
||||
int end;
|
||||
} re_subexp_t;
|
||||
|
||||
struct re_state_table_entry
|
||||
{
|
||||
int num;
|
||||
int alloc;
|
||||
re_dfastate_t **array;
|
||||
};
|
||||
|
||||
/* Array type used in re_sub_match_last_t and re_sub_match_top_t. */
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int next_idx;
|
||||
int alloc;
|
||||
re_dfastate_t **array;
|
||||
} state_array_t;
|
||||
|
||||
/* Store information about the node NODE whose type is OP_CLOSE_SUBEXP. */
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int node;
|
||||
int str_idx; /* The position NODE match at. */
|
||||
state_array_t path;
|
||||
} re_sub_match_last_t;
|
||||
|
||||
/* Store information about the node NODE whose type is OP_OPEN_SUBEXP.
|
||||
And information about the node, whose type is OP_CLOSE_SUBEXP,
|
||||
corresponding to NODE is stored in LASTS. */
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int str_idx;
|
||||
int node;
|
||||
int next_last_offset;
|
||||
state_array_t *path;
|
||||
int alasts; /* Allocation size of LASTS. */
|
||||
int nlasts; /* The number of LASTS. */
|
||||
re_sub_match_last_t **lasts;
|
||||
} re_sub_match_top_t;
|
||||
|
||||
struct re_backref_cache_entry
|
||||
{
|
||||
int node;
|
||||
int str_idx;
|
||||
int subexp_from;
|
||||
int subexp_to;
|
||||
int flag;
|
||||
};
|
||||
|
||||
typedef struct
|
||||
{
|
||||
/* The string object corresponding to the input string. */
|
||||
re_string_t input;
|
||||
#if defined _LIBC || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L)
|
||||
re_dfa_t *const dfa;
|
||||
#else
|
||||
re_dfa_t *dfa;
|
||||
#endif
|
||||
/* EFLAGS of the argument of regexec. */
|
||||
int eflags;
|
||||
/* Where the matching ends. */
|
||||
int match_last;
|
||||
int last_node;
|
||||
/* The state log used by the matcher. */
|
||||
re_dfastate_t **state_log;
|
||||
int state_log_top;
|
||||
/* Back reference cache. */
|
||||
int nbkref_ents;
|
||||
int abkref_ents;
|
||||
struct re_backref_cache_entry *bkref_ents;
|
||||
int max_mb_elem_len;
|
||||
int nsub_tops;
|
||||
int asub_tops;
|
||||
re_sub_match_top_t **sub_tops;
|
||||
} re_match_context_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int cur_bkref;
|
||||
int cls_subexp_idx;
|
||||
|
||||
re_dfastate_t **sifted_states;
|
||||
re_dfastate_t **limited_states;
|
||||
|
||||
re_node_set limits;
|
||||
|
||||
int last_node;
|
||||
int last_str_idx;
|
||||
int check_subexp;
|
||||
} re_sift_context_t;
|
||||
|
||||
struct re_fail_stack_ent_t
|
||||
{
|
||||
int idx;
|
||||
int node;
|
||||
regmatch_t *regs;
|
||||
re_node_set eps_via_nodes;
|
||||
};
|
||||
|
||||
struct re_fail_stack_t
|
||||
{
|
||||
int num;
|
||||
int alloc;
|
||||
struct re_fail_stack_ent_t *stack;
|
||||
};
|
||||
|
||||
struct re_dfa_t
|
||||
{
|
||||
re_subexp_t *subexps;
|
||||
re_token_t *nodes;
|
||||
int nodes_alloc;
|
||||
int nodes_len;
|
||||
int *nexts;
|
||||
int *org_indices;
|
||||
re_node_set *edests;
|
||||
re_node_set *eclosures;
|
||||
re_node_set *inveclosures;
|
||||
struct re_state_table_entry *state_table;
|
||||
re_dfastate_t *init_state;
|
||||
re_dfastate_t *init_state_word;
|
||||
re_dfastate_t *init_state_nl;
|
||||
re_dfastate_t *init_state_begbuf;
|
||||
bin_tree_t *str_tree;
|
||||
bin_tree_storage_t *str_tree_storage;
|
||||
re_bitset_ptr_t sb_char;
|
||||
int str_tree_storage_idx;
|
||||
|
||||
/* number of subexpressions `re_nsub' is in regex_t. */
|
||||
int subexps_alloc;
|
||||
unsigned int state_hash_mask;
|
||||
int states_alloc;
|
||||
int init_node;
|
||||
int nbackref; /* The number of backreference in this dfa. */
|
||||
/* Bitmap expressing which backreference is used. */
|
||||
unsigned int used_bkref_map;
|
||||
unsigned int has_plural_match : 1;
|
||||
/* If this dfa has "multibyte node", which is a backreference or
|
||||
a node which can accept multibyte character or multi character
|
||||
collating element. */
|
||||
unsigned int has_mb_node : 1;
|
||||
unsigned int is_utf8 : 1;
|
||||
unsigned int map_notascii : 1;
|
||||
unsigned int word_ops_used : 1;
|
||||
int mb_cur_max;
|
||||
bitset word_char;
|
||||
reg_syntax_t syntax;
|
||||
#ifdef DEBUG
|
||||
char* re_str;
|
||||
#endif
|
||||
};
|
||||
|
||||
#ifndef RE_NO_INTERNAL_PROTOTYPES
|
||||
static reg_errcode_t re_node_set_alloc (re_node_set *set, int size) internal_function;
|
||||
static reg_errcode_t re_node_set_init_1 (re_node_set *set, int elem) internal_function;
|
||||
static reg_errcode_t re_node_set_init_2 (re_node_set *set, int elem1,
|
||||
int elem2) internal_function;
|
||||
#define re_node_set_init_empty(set) memset (set, '\0', sizeof (re_node_set))
|
||||
static reg_errcode_t re_node_set_init_copy (re_node_set *dest,
|
||||
const re_node_set *src) internal_function;
|
||||
static reg_errcode_t re_node_set_add_intersect (re_node_set *dest,
|
||||
const re_node_set *src1,
|
||||
const re_node_set *src2) internal_function;
|
||||
static reg_errcode_t re_node_set_init_union (re_node_set *dest,
|
||||
const re_node_set *src1,
|
||||
const re_node_set *src2) internal_function;
|
||||
static reg_errcode_t re_node_set_merge (re_node_set *dest,
|
||||
const re_node_set *src) internal_function;
|
||||
static int re_node_set_insert (re_node_set *set, int elem) internal_function;
|
||||
static int re_node_set_compare (const re_node_set *set1,
|
||||
const re_node_set *set2) internal_function;
|
||||
static int re_node_set_contains (const re_node_set *set, int elem) internal_function;
|
||||
static void re_node_set_remove_at (re_node_set *set, int idx) internal_function;
|
||||
#define re_node_set_remove(set,id) \
|
||||
(re_node_set_remove_at (set, re_node_set_contains (set, id) - 1))
|
||||
#define re_node_set_empty(p) ((p)->nelem = 0)
|
||||
#define re_node_set_free(set) re_free ((set)->elems)
|
||||
static int re_dfa_add_node (re_dfa_t *dfa, re_token_t token, int mode) internal_function;
|
||||
static re_dfastate_t *re_acquire_state (reg_errcode_t *err, re_dfa_t *dfa,
|
||||
const re_node_set *nodes) internal_function;
|
||||
static re_dfastate_t *re_acquire_state_context (reg_errcode_t *err,
|
||||
re_dfa_t *dfa,
|
||||
const re_node_set *nodes,
|
||||
unsigned int context) internal_function;
|
||||
static void free_state (re_dfastate_t *state) internal_function;
|
||||
#endif
|
||||
|
||||
|
||||
typedef enum
|
||||
{
|
||||
SB_CHAR,
|
||||
MB_CHAR,
|
||||
EQUIV_CLASS,
|
||||
COLL_SYM,
|
||||
CHAR_CLASS
|
||||
} bracket_elem_type;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
bracket_elem_type type;
|
||||
union
|
||||
{
|
||||
unsigned char ch;
|
||||
unsigned char *name;
|
||||
wchar_t wch;
|
||||
} opr;
|
||||
} bracket_elem_t;
|
||||
|
||||
|
||||
/* Inline functions for bitset operation. */
|
||||
static inline void
|
||||
bitset_not (set)
|
||||
bitset set;
|
||||
{
|
||||
int bitset_i;
|
||||
for (bitset_i = 0; bitset_i < BITSET_UINTS; ++bitset_i)
|
||||
set[bitset_i] = ~set[bitset_i];
|
||||
}
|
||||
|
||||
static inline void
|
||||
bitset_merge (dest, src)
|
||||
bitset dest;
|
||||
const bitset src;
|
||||
{
|
||||
int bitset_i;
|
||||
for (bitset_i = 0; bitset_i < BITSET_UINTS; ++bitset_i)
|
||||
dest[bitset_i] |= src[bitset_i];
|
||||
}
|
||||
|
||||
static inline void
|
||||
bitset_not_merge (dest, src)
|
||||
bitset dest;
|
||||
const bitset src;
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < BITSET_UINTS; ++i)
|
||||
dest[i] |= ~src[i];
|
||||
}
|
||||
|
||||
static inline void
|
||||
bitset_mask (dest, src)
|
||||
bitset dest;
|
||||
const bitset src;
|
||||
{
|
||||
int bitset_i;
|
||||
for (bitset_i = 0; bitset_i < BITSET_UINTS; ++bitset_i)
|
||||
dest[bitset_i] &= src[bitset_i];
|
||||
}
|
||||
|
||||
#if defined RE_ENABLE_I18N && !defined RE_NO_INTERNAL_PROTOTYPES
|
||||
/* Inline functions for re_string. */
|
||||
static inline int
|
||||
re_string_char_size_at (pstr, idx)
|
||||
const re_string_t *pstr;
|
||||
int idx;
|
||||
{
|
||||
int byte_idx;
|
||||
if (pstr->mb_cur_max == 1)
|
||||
return 1;
|
||||
for (byte_idx = 1; idx + byte_idx < pstr->valid_len; ++byte_idx)
|
||||
if (pstr->wcs[idx + byte_idx] != WEOF)
|
||||
break;
|
||||
return byte_idx;
|
||||
}
|
||||
|
||||
static inline wint_t
|
||||
re_string_wchar_at (pstr, idx)
|
||||
const re_string_t *pstr;
|
||||
int idx;
|
||||
{
|
||||
if (pstr->mb_cur_max == 1)
|
||||
return (wint_t) pstr->mbs[idx];
|
||||
return (wint_t) pstr->wcs[idx];
|
||||
}
|
||||
|
||||
static int
|
||||
re_string_elem_size_at (pstr, idx)
|
||||
const re_string_t *pstr;
|
||||
int idx;
|
||||
{
|
||||
#ifdef _LIBC
|
||||
const unsigned char *p, *extra;
|
||||
const int32_t *table, *indirect;
|
||||
int32_t tmp;
|
||||
# include <locale/weight.h>
|
||||
uint_fast32_t nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
|
||||
|
||||
if (nrules != 0)
|
||||
{
|
||||
table = (const int32_t *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEMB);
|
||||
extra = (const unsigned char *)
|
||||
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAMB);
|
||||
indirect = (const int32_t *) _NL_CURRENT (LC_COLLATE,
|
||||
_NL_COLLATE_INDIRECTMB);
|
||||
p = pstr->mbs + idx;
|
||||
tmp = findidx (&p);
|
||||
return p - pstr->mbs - idx;
|
||||
}
|
||||
else
|
||||
#endif /* _LIBC */
|
||||
return 1;
|
||||
}
|
||||
#endif /* RE_ENABLE_I18N */
|
||||
|
||||
#endif /* _REGEX_INTERNAL_H */
|
||||
-4269
File diff suppressed because it is too large.
Load diff
+337
@@ -0,0 +1,337 @@
|
||||
/* A simplified snprintf, without floating point support */
|
||||
|
||||
/* AIX requires this to be the first thing in the file. */
|
||||
#ifdef _AIX
|
||||
#pragma alloca
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#ifndef __GNUC__
|
||||
# if HAVE_ALLOCA_H
|
||||
# include <alloca.h>
|
||||
# else
|
||||
# ifndef alloca /* predefined by HP cc +Olibcalls */
|
||||
char *alloca ();
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef BOOTSTRAP
|
||||
#include <stdio.h>
|
||||
#endif
|
||||
#ifdef HAVE_STDARG_H
|
||||
#include <stdarg.h>
|
||||
#else
|
||||
#include <varargs.h>
|
||||
#endif
|
||||
#ifdef HAVE_STDLIB_H
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
#ifdef HAVE_STRING_H
|
||||
#include <string.h>
|
||||
#endif
|
||||
#include <ctype.h>
|
||||
|
||||
#include "basicdefs.h"
|
||||
|
||||
#define MINUS_FLAG 1
|
||||
#define PLUS_FLAG 2
|
||||
#define SPACE_FLAG 4
|
||||
#define ALTERNATE_FLAG 8
|
||||
#define ZERO_FLAG 16
|
||||
|
||||
static int
|
||||
compute_number_length (num, base, width, prec, flags, minusp)
|
||||
unsigned long num;
|
||||
unsigned base;
|
||||
int width;
|
||||
int prec;
|
||||
int flags;
|
||||
int minusp;
|
||||
{
|
||||
int len = 0;
|
||||
int i;
|
||||
|
||||
/* length of the number itself */
|
||||
do
|
||||
{
|
||||
len++;
|
||||
num /= base;
|
||||
}
|
||||
while (num);
|
||||
|
||||
/* ...padded to prec characters */
|
||||
if (prec > len) len = prec;
|
||||
|
||||
/* ...with alternate prefix */
|
||||
if (flags & ALTERNATE_FLAG && (base == 16 || base == 8))
|
||||
len += base / 8;
|
||||
|
||||
/* ...with the sign before it */
|
||||
if (minusp || (flags & SPACE_FLAG) || (flags & PLUS_FLAG))
|
||||
len++;
|
||||
|
||||
/* ...and padded with spaces or zeroes (zeroes go
|
||||
before the sign, actually. This routine does
|
||||
not consider that but vsprintf will). */
|
||||
|
||||
return (width > len) ? width : len;
|
||||
}
|
||||
|
||||
/* These can't be made into a function... */
|
||||
|
||||
#define PARSE_INT_FORMAT(res, args) \
|
||||
if (long_flag) \
|
||||
res = va_arg(args, long); \
|
||||
else \
|
||||
res = va_arg(args, int)
|
||||
|
||||
#define PARSE_UINT_FORMAT(res, args) \
|
||||
if (long_flag) \
|
||||
res = va_arg(args, unsigned long); \
|
||||
else \
|
||||
res = va_arg(args, unsigned int)
|
||||
|
||||
static int
|
||||
compute_length (fmt, args)
|
||||
const char *fmt;
|
||||
va_list args;
|
||||
{
|
||||
char c;
|
||||
const char *format;
|
||||
size_t sz;
|
||||
|
||||
/* Go through the string and find the correct length. */
|
||||
sz = 0;
|
||||
format = fmt;
|
||||
while (c = *format++)
|
||||
{
|
||||
if (c == '%')
|
||||
{
|
||||
int flags = 0;
|
||||
int width = 0;
|
||||
int prec = -1;
|
||||
int long_flag = 0;
|
||||
|
||||
/* flags */
|
||||
while ((c = *format++))
|
||||
{
|
||||
if (c == '-')
|
||||
flags |= MINUS_FLAG;
|
||||
else if (c == '+')
|
||||
flags |= PLUS_FLAG;
|
||||
else if (c == ' ')
|
||||
flags |= SPACE_FLAG;
|
||||
else if (c == '#')
|
||||
flags |= ALTERNATE_FLAG;
|
||||
else if (c == '0')
|
||||
flags |= ZERO_FLAG;
|
||||
else
|
||||
break;
|
||||
}
|
||||
|
||||
if (flags & PLUS_FLAG)
|
||||
flags &= ~SPACE_FLAG;
|
||||
if (flags & MINUS_FLAG)
|
||||
flags &= ~ZERO_FLAG;
|
||||
|
||||
/* width */
|
||||
if (isdigit (c))
|
||||
do
|
||||
{
|
||||
width = width * 10 + c - '0';
|
||||
c = *format++;
|
||||
}
|
||||
while (isdigit (c));
|
||||
else if (c == '*')
|
||||
{
|
||||
width = va_arg (args, int);
|
||||
c = *format++;
|
||||
}
|
||||
|
||||
/* precision */
|
||||
if (c == '.')
|
||||
{
|
||||
prec = 0;
|
||||
c = *format++;
|
||||
if (isdigit (c))
|
||||
do
|
||||
{
|
||||
prec = prec * 10 + c - '0';
|
||||
c = *format++;
|
||||
}
|
||||
while (isdigit (c));
|
||||
else if (c == '*')
|
||||
{
|
||||
prec = va_arg (args, int);
|
||||
c = *format++;
|
||||
}
|
||||
}
|
||||
|
||||
/* size */
|
||||
|
||||
if (c == 'h')
|
||||
{
|
||||
c = *format++;
|
||||
if (c == 'h')
|
||||
c = *format++;
|
||||
}
|
||||
else if (c == 'l')
|
||||
{
|
||||
long_flag = 1;
|
||||
c = *format++;
|
||||
}
|
||||
|
||||
switch (c)
|
||||
{
|
||||
case 'c':
|
||||
sz += width + 1;
|
||||
break;
|
||||
|
||||
case 's':
|
||||
{
|
||||
int len;
|
||||
char *arg;
|
||||
|
||||
arg = va_arg (args, char *);
|
||||
len = strlen (arg);
|
||||
|
||||
if (prec != -1 && len > prec)
|
||||
len = prec;
|
||||
|
||||
sz += (width > len) ? width : len;
|
||||
break;
|
||||
}
|
||||
|
||||
case 'd':
|
||||
case 'i':
|
||||
{
|
||||
long arg;
|
||||
unsigned long num;
|
||||
int minusp = 0;
|
||||
|
||||
PARSE_INT_FORMAT (arg, args);
|
||||
|
||||
if (arg < 0)
|
||||
{
|
||||
minusp = 1;
|
||||
num = -arg;
|
||||
}
|
||||
else
|
||||
num = arg;
|
||||
|
||||
sz += compute_number_length(num, 10, width,
|
||||
prec, flags, minusp);
|
||||
break;
|
||||
}
|
||||
|
||||
case 'u':
|
||||
{
|
||||
unsigned long arg;
|
||||
|
||||
PARSE_UINT_FORMAT (arg, args);
|
||||
|
||||
sz += compute_number_length(arg, 10, width,
|
||||
prec, flags, 0);
|
||||
break;
|
||||
}
|
||||
|
||||
case 'o':
|
||||
{
|
||||
unsigned long arg;
|
||||
|
||||
PARSE_UINT_FORMAT (arg, args);
|
||||
|
||||
sz += compute_number_length(arg, 8, width,
|
||||
prec, flags, 0);
|
||||
break;
|
||||
}
|
||||
|
||||
case 'p':
|
||||
flags |= ALTERNATE_FLAG;
|
||||
/* fall through */
|
||||
|
||||
case 'x':
|
||||
case 'X':
|
||||
{
|
||||
unsigned long arg;
|
||||
|
||||
PARSE_UINT_FORMAT (arg, args);
|
||||
|
||||
sz += compute_number_length(arg, 16, width,
|
||||
prec, flags, 0);
|
||||
break;
|
||||
}
|
||||
|
||||
case 'n':
|
||||
break;
|
||||
|
||||
case '%':
|
||||
sz++;
|
||||
break;
|
||||
|
||||
default:
|
||||
sz += 2;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
sz++;
|
||||
}
|
||||
|
||||
return sz;
|
||||
}
|
||||
|
||||
static int
|
||||
my_vsnprintf (str, sz, fmt, args)
|
||||
char *str;
|
||||
size_t sz;
|
||||
const char *fmt;
|
||||
va_list args;
|
||||
{
|
||||
char *buf;
|
||||
size_t realsz = compute_length(fmt, args);
|
||||
|
||||
/* Here, we have to count the null character at the end! */
|
||||
if (realsz + 1 < sz)
|
||||
buf = alloca (realsz + 1);
|
||||
else
|
||||
buf = str;
|
||||
|
||||
realsz = vsprintf(buf, fmt, args);
|
||||
if (buf != str)
|
||||
memcpy(str, buf, sz);
|
||||
|
||||
return realsz;
|
||||
}
|
||||
|
||||
int
|
||||
#ifdef HAVE_STDARG_H
|
||||
snprintf (char *str, size_t sz, const char *format,...)
|
||||
#else
|
||||
snprintf (va_alist)
|
||||
va_dcl
|
||||
#endif
|
||||
{
|
||||
va_list args;
|
||||
int ret;
|
||||
#ifdef HAVE_STDARG_H
|
||||
va_start (args, format);
|
||||
#else
|
||||
char *str;
|
||||
size_t sz;
|
||||
char *format;
|
||||
|
||||
va_start (args);
|
||||
str = va_arg(args, char *);
|
||||
sz = va_arg(args, size_t);
|
||||
format = va_arg(args, char *);
|
||||
#endif
|
||||
|
||||
ret = my_vsnprintf (str, sz, format, args);
|
||||
va_end (args);
|
||||
return ret;
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
Based on PCRE-3.4, which was written by:
|
||||
|
||||
Philip Hazel <ph10@cam.ac.uk>
|
||||
|
||||
University of Cambridge Computing Service,
|
||||
Cambridge, England. Phone: +44 1223 334714.
|
||||
|
||||
Copyright (c) 1997-2000 University of Cambridge
|
||||
+283
@@ -0,0 +1,283 @@
|
||||
2004-03-04 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regcomp.c: fix bugs in is_endline.
|
||||
|
||||
2004-02-29 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regperl.c, regposix.c: move common functions...
|
||||
* regcomp.c: ... here.
|
||||
|
||||
2004-02-29 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* internal.h: add OP_ANCHOR_MATCH, ESC_G.
|
||||
* regdebug.c: Likewise.
|
||||
* regexec.c: Likewise.
|
||||
* regperl.c: Likewise.
|
||||
* regposix.c: Likewise.
|
||||
* regstudy.c: Likewise.
|
||||
|
||||
2004-01-15 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regexp.c: drop regexec2, replace with REG_STARTEND
|
||||
found in NetBSD regexp.
|
||||
* regexp.h: likewise.
|
||||
|
||||
2003-09-19 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regposix.c: recognize \s and \S.
|
||||
|
||||
* regposix.c: compile (a){0,2} to (a)?(a)? instead
|
||||
of ((a)?(a))? so that it is possible to...
|
||||
* regexec.c: not assign offsets to optional brackets
|
||||
which match nothing, e.g. when matching (b?){1,2} to
|
||||
`b'. Actually, we do assign offsets the first time;
|
||||
this does not hamper the POSIXicity of ssed because
|
||||
anyway we don't get the wrong substitution for the
|
||||
backreference on the RHS: e.g. if you have
|
||||
s/(b?)?/<\1>/ with an empty pattern space, you'll get
|
||||
<> in the pattern space no matter if \1 did not match
|
||||
or if it matched the empty string at offsets [0,0).
|
||||
|
||||
2003-01-03 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regtables.c (pcre_maketables): add [:blank:]
|
||||
* internal.h (cbit_blank): new
|
||||
* regperl.c: add [:blank:]
|
||||
* regposix.c: add [:blank:]
|
||||
|
||||
2002-09-18 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regposix.c (pcre_posix_compile_nuls): fix
|
||||
error in determining length of .{1,64}
|
||||
* regperl.c (pcre_perl_compile_nuls): likewise
|
||||
|
||||
2002-01-06 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regdebug.c: add _ONCE repetitions
|
||||
* regexec.c: likewise
|
||||
* regstudy.c: likewise
|
||||
* internal.h: likewise
|
||||
|
||||
2001-12-31 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
** Version 3.55 released
|
||||
|
||||
* regposix.c (check_escape): inside a character class,
|
||||
parse unknown escapes (like \" or \p) as two separate
|
||||
characters. Signaled by John Fremlin.
|
||||
|
||||
2001-12-27 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
** Version 3.54 released
|
||||
|
||||
2001-12-19 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
** Version 3.53 released
|
||||
|
||||
* regstudy.c (set_boyer_moore, set_start_bits): use new
|
||||
OP_TYPE and OP_TYPENOT* opcodes instead of OP_DIGIT & co.
|
||||
* regdebug.c (pcre_debug): likewise (print them)
|
||||
* regperl.c (compile_branch): likewise (compile them)
|
||||
* regposix.c (compile_branch): likewise (compile them)
|
||||
* internal.h: likewise (define them); refine meaning of
|
||||
bits in ctype table to allow for simpler OP_TYPE* code
|
||||
* regtables.c (pcre_maketables): set newline table.
|
||||
|
||||
2001-12-17 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regstudy.c (set_bmtable, set_boyer_moore): implemented
|
||||
Boyer-Moore algorithm for first character search
|
||||
* regexec.c (pcre_exec): use the Boyer-Moore data
|
||||
|
||||
2001-12-14 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* internal.h (pcre_extra): encapsulate start_bits in a union,
|
||||
define PCRE_STUDY_BM
|
||||
* regexec.c (pcre_match): access the `data' union in pcre_extra
|
||||
* reginfo.c (pcre_info): likewise
|
||||
* regstudy.c (pcre_study): likewise
|
||||
|
||||
2001-12-13 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
*** Version 3.52 released.
|
||||
|
||||
2001-12-12 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* internal.h: add max_match_size to pcre and compile_data
|
||||
* regexec.c (pcre_match): use re->max_match_size
|
||||
information
|
||||
* regexec.c (pcre_match) [DEBUG]: debug first character
|
||||
optimization
|
||||
* regposix.c (compile_branch, pcre_posix_compile_nuls):
|
||||
optimize regexps like xxxxxx$ where xxxxxx
|
||||
cannot match more than a certain number of characters.
|
||||
* regposix.c (is_endline): new function.
|
||||
|
||||
2001-10-15 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
*** Version 3.51 released.
|
||||
|
||||
2001-10-13 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regposix.c(pcre_posix_compile_nuls,
|
||||
basic_to_extended_regexp): fix code overflow
|
||||
bug when a [*+?] is treated as a literal character. This
|
||||
is actually not mandated by POSIX, which specifies
|
||||
"undefined behavior", but an internal error is not what
|
||||
I had in mind...
|
||||
|
||||
2001-09-25 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
*** Version 3.50 released.
|
||||
|
||||
2001-06-05 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
*** Version 3.49 released
|
||||
|
||||
* regposix.c(check_escape, pcre_posix_compile_nuls): in
|
||||
POSIX regular expressions, inside classes, unrecognized
|
||||
escapes must make the backslash and the following character
|
||||
*really* independent; regexps like [/\] were previously broken.
|
||||
|
||||
2001-03-22 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
*** Version 3.48 released
|
||||
|
||||
2001-03-02 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
*** Version 3.47 released
|
||||
|
||||
2001-02-21 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
*** Version 3.46 released
|
||||
|
||||
2001-02-09 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regposix.c(compile_branch, read_repeat_counts): support
|
||||
GNU regex's behavior of compiling a{1,2}{2,3} like a{2,6}
|
||||
(multiplying the minimum and maximum counts)
|
||||
* regposix.c(basic_to_extended_regexp): compile * as a
|
||||
literal asterisk if at the start of a branch
|
||||
|
||||
2001-01-04 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regexp.c(regncomp): pass REG_EXTENDED to the
|
||||
compilation functions (becomes PCRE_EXTENDED)
|
||||
|
||||
2001-01-03 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regposix.c(check_escape): don't support things like
|
||||
[A\W]: it now means the same as [AW]. However,
|
||||
[\n\r] still means a CR or LF (that is, escapes that
|
||||
are character classes match a literal character, but
|
||||
escapes that match non-printable characters match the
|
||||
character).
|
||||
* regposix.c(compile_branch): simplified to account
|
||||
for the change above.
|
||||
|
||||
2000-12-21 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* pcre.h [BOOTSTRAP]: include malloc.h
|
||||
|
||||
* regexp.c: modified POSIX error messages to resemble
|
||||
PCRE error messages whenever possible.
|
||||
|
||||
* regposix.c(compile_branch): raise an error if unmatched
|
||||
braces are found.
|
||||
|
||||
2000-12-11 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regposix.c: implement \o and \d like in GNU sed 3.02.80;
|
||||
removed \0.
|
||||
|
||||
2000-12-10 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regposix.c(pcre_posix_compile_nuls): internationalized.
|
||||
* regperl.c(pcre_compile_nuls): internationalized.
|
||||
* pcregrep.c: internationalized.
|
||||
* internal.h: add standard NLS crap.
|
||||
|
||||
* pcre.h: defined PCRE_ENGLISH_ERRORS
|
||||
* regexp.c: use PCRE_ENGLISH_ERRORS
|
||||
|
||||
2000-12-08 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regexp.c(regerror): modified a bit to ease i18n.
|
||||
|
||||
* regposix.c: converted the behavior of \<digits> to POSIX
|
||||
(e.g. \11 is not the eleventh backref and \321 is not an
|
||||
octal sequence).
|
||||
|
||||
2000-12-07 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regdebug.c: added \< and \> to the opcode names table
|
||||
|
||||
2000-11-21 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regperl.c: handle regexps with embedded NULs
|
||||
* regposix.c: ditto
|
||||
|
||||
* pcre.h: use prototypes
|
||||
* internal.h: ditto
|
||||
* regexp.h: ditto
|
||||
|
||||
* regexp.h: declared regexec2, regncomp
|
||||
* regexp.c: defined regexec2, regncomp
|
||||
|
||||
2000-11-16 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regposix.c: handle ^ and $ as literals if they're not the first or
|
||||
the last character, respectively.
|
||||
|
||||
* regexp.c(regexec): handle correctly pmatch == NULL
|
||||
* regexec.c(pcre_exec): handle correctly pmatch == NULL
|
||||
|
||||
2000-11-15 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* regposix.c: removed [:^alnum:] and the like; added \`
|
||||
and \'; added basic regular expressions.
|
||||
|
||||
* regexp.c(regnexec): new function
|
||||
|
||||
2000-11-14 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* internal.h: declared ESC_LESS and ESC_GREATER,
|
||||
ESC_FIRST_CONSUME and ESC_LAST_CONSUME, OP_BEG_WORD and OP_END_WORD
|
||||
|
||||
* regexec.c(match): added OP_BEG_WORD and OP_END_WORD
|
||||
|
||||
* regposix.c: created from regperl.c
|
||||
|
||||
* regperl.c(compile_branch): use ESC_FIRST_CONSUME and ESC_LAST_CONSUME
|
||||
|
||||
* regexp.c(regcomp): handle PCRE_DOTALL differently for Perl and POSIX
|
||||
regular expressions.
|
||||
|
||||
2000-11-13 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
Started work to merge with sed.
|
||||
|
||||
* AUTHORS: inserted myself...
|
||||
* COPYING: replaced with GNU GPL. Original terms stay in the
|
||||
LICENCE file.
|
||||
|
||||
* Makefile.in: remove libtool usage, not good for a bootstrapping
|
||||
tool such as sed.
|
||||
* configure.in: likewise; also changed AC_CHECK_FUNCS to
|
||||
AC_REPLACE_FUNCS for memmove.
|
||||
|
||||
* regdebug.c: new file, created from part of pcre.c.
|
||||
* regexec.c: new file, created from part of pcre.c. Removed UTF-8.
|
||||
* reginfo.c: new file, created from part of pcre.c.
|
||||
* internal.h: don't do strange things with memmove declarations.
|
||||
* regperl.c: new file, created from part of pcre.c.
|
||||
* pcre.c: split into many sources, removed.
|
||||
|
||||
* regexp.c(regcomp, regexec): new name of pcreposix.c; use pcre_study
|
||||
* regexp.h: new name of pcreposix.h; added re_study member
|
||||
|
||||
2000-11-13 Paolo Bonzini <bonzini@gnu.org>
|
||||
|
||||
* pcre.c(pcre_compile): Removed support for UTF-8.
|
||||
The default tables are generated at run-time rather than
|
||||
at compile-time to support cross compiling.
|
||||
@@ -0,0 +1,655 @@
|
||||
ChangeLog for PCRE
|
||||
------------------
|
||||
|
||||
|
||||
Version 3.4 22-Aug-00
|
||||
---------------------
|
||||
|
||||
1. Fixed typo in pcre.h: unsigned const char * changed to const unsigned char *.
|
||||
|
||||
2. Diagnose condition (?(0) as an error instead of crashing on matching.
|
||||
|
||||
|
||||
Version 3.3 01-Aug-00
|
||||
---------------------
|
||||
|
||||
1. If an octal character was given, but the value was greater than \377, it
|
||||
was not getting masked to the least significant bits, as documented. This could
|
||||
lead to crashes in some systems.
|
||||
|
||||
2. Perl 5.6 (if not earlier versions) accepts classes like [a-\d] and treats
|
||||
the hyphen as a literal. PCRE used to give an error; it now behaves like Perl.
|
||||
|
||||
3. Added the functions pcre_free_substring() and pcre_free_substring_list().
|
||||
These just pass their arguments on to (pcre_free)(), but they are provided
|
||||
because some uses of PCRE bind it to non-C systems that can call its functions,
|
||||
but cannot call free() or pcre_free() directly.
|
||||
|
||||
4. Add "make test" as a synonym for "make check". Corrected some comments in
|
||||
the Makefile.
|
||||
|
||||
5. Add $(DESTDIR)/ in front of all the paths in the "install" target in the
|
||||
Makefile.
|
||||
|
||||
6. Changed the name of pgrep to pcregrep, because Solaris has introduced a
|
||||
command called pgrep for grepping around the active processes.
|
||||
|
||||
7. Added the beginnings of support for UTF-8 character strings.
|
||||
|
||||
8. Arranged for the Makefile to pass over the settings of CC, CFLAGS, and
|
||||
RANLIB to ./ltconfig so that they are used by libtool. I think these are all
|
||||
the relevant ones. (AR is not passed because ./ltconfig does its own figuring
|
||||
out for the ar command.)
|
||||
|
||||
|
||||
Version 3.2 12-May-00
|
||||
---------------------
|
||||
|
||||
This is purely a bug fixing release.
|
||||
|
||||
1. If the pattern /((Z)+|A)*/ was matched agained ZABCDEFG it matched Z instead
|
||||
of ZA. This was just one example of several cases that could provoke this bug,
|
||||
which was introduced by change 9 of version 2.00. The code for breaking
|
||||
infinite loops after an iteration that matches an empty string was't working
|
||||
correctly.
|
||||
|
||||
2. The pcretest program was not imitating Perl correctly for the pattern /a*/g
|
||||
when matched against abbab (for example). After matching an empty string, it
|
||||
wasn't forcing anchoring when setting PCRE_NOTEMPTY for the next attempt; this
|
||||
caused it to match further down the string than it should.
|
||||
|
||||
3. The code contained an inclusion of sys/types.h. It isn't clear why this
|
||||
was there because it doesn't seem to be needed, and it causes trouble on some
|
||||
systems, as it is not a Standard C header. It has been removed.
|
||||
|
||||
4. Made 4 silly changes to the source to avoid stupid compiler warnings that
|
||||
were reported on the Macintosh. The changes were from
|
||||
|
||||
while ((c = *(++ptr)) != 0 && c != '\n');
|
||||
to
|
||||
while ((c = *(++ptr)) != 0 && c != '\n') ;
|
||||
|
||||
Totally extraordinary, but if that's what it takes...
|
||||
|
||||
5. PCRE is being used in one environment where neither memmove() nor bcopy() is
|
||||
available. Added HAVE_BCOPY and an autoconf test for it; if neither
|
||||
HAVE_MEMMOVE nor HAVE_BCOPY is set, use a built-in emulation function which
|
||||
assumes the way PCRE uses memmove() (always moving upwards).
|
||||
|
||||
6. PCRE is being used in one environment where strchr() is not available. There
|
||||
was only one use in pcre.c, and writing it out to avoid strchr() probably gives
|
||||
faster code anyway.
|
||||
|
||||
|
||||
Version 3.1 09-Feb-00
|
||||
---------------------
|
||||
|
||||
The only change in this release is the fixing of some bugs in Makefile.in for
|
||||
the "install" target:
|
||||
|
||||
(1) It was failing to install pcreposix.h.
|
||||
|
||||
(2) It was overwriting the pcre.3 man page with the pcreposix.3 man page.
|
||||
|
||||
|
||||
Version 3.0 01-Feb-00
|
||||
---------------------
|
||||
|
||||
1. Add support for the /+ modifier to perltest (to output $` like it does in
|
||||
pcretest).
|
||||
|
||||
2. Add support for the /g modifier to perltest.
|
||||
|
||||
3. Fix pcretest so that it behaves even more like Perl for /g when the pattern
|
||||
matches null strings.
|
||||
|
||||
4. Fix perltest so that it doesn't do unwanted things when fed an empty
|
||||
pattern. Perl treats empty patterns specially - it reuses the most recent
|
||||
pattern, which is not what we want. Replace // by /(?#)/ in order to avoid this
|
||||
effect.
|
||||
|
||||
5. The POSIX interface was broken in that it was just handing over the POSIX
|
||||
captured string vector to pcre_exec(), but (since release 2.00) PCRE has
|
||||
required a bigger vector, with some working space on the end. This means that
|
||||
the POSIX wrapper now has to get and free some memory, and copy the results.
|
||||
|
||||
6. Added some simple autoconf support, placing the test data and the
|
||||
documentation in separate directories, re-organizing some of the
|
||||
information files, and making it build pcre-config (a GNU standard). Also added
|
||||
libtool support for building PCRE as a shared library, which is now the
|
||||
default.
|
||||
|
||||
7. Got rid of the leading zero in the definition of PCRE_MINOR because 08 and
|
||||
09 are not valid octal constants. Single digits will be used for minor values
|
||||
less than 10.
|
||||
|
||||
8. Defined REG_EXTENDED and REG_NOSUB as zero in the POSIX header, so that
|
||||
existing programs that set these in the POSIX interface can use PCRE without
|
||||
modification.
|
||||
|
||||
9. Added a new function, pcre_fullinfo() with an extensible interface. It can
|
||||
return all that pcre_info() returns, plus additional data. The pcre_info()
|
||||
function is retained for compatibility, but is considered to be obsolete.
|
||||
|
||||
10. Added experimental recursion feature (?R) to handle one common case that
|
||||
Perl 5.6 will be able to do with (?p{...}).
|
||||
|
||||
11. Added support for POSIX character classes like [:alpha:], which Perl is
|
||||
adopting.
|
||||
|
||||
|
||||
Version 2.08 31-Aug-99
|
||||
----------------------
|
||||
|
||||
1. When startoffset was not zero and the pattern began with ".*", PCRE was not
|
||||
trying to match at the startoffset position, but instead was moving forward to
|
||||
the next newline as if a previous match had failed.
|
||||
|
||||
2. pcretest was not making use of PCRE_NOTEMPTY when repeating for /g and /G,
|
||||
and could get into a loop if a null string was matched other than at the start
|
||||
of the subject.
|
||||
|
||||
3. Added definitions of PCRE_MAJOR and PCRE_MINOR to pcre.h so the version can
|
||||
be distinguished at compile time, and for completeness also added PCRE_DATE.
|
||||
|
||||
5. Added Paul Sokolovsky's minor changes to make it easy to compile a Win32 DLL
|
||||
in GnuWin32 environments.
|
||||
|
||||
|
||||
Version 2.07 29-Jul-99
|
||||
----------------------
|
||||
|
||||
1. The documentation is now supplied in plain text form and HTML as well as in
|
||||
the form of man page sources.
|
||||
|
||||
2. C++ compilers don't like assigning (void *) values to other pointer types.
|
||||
In particular this affects malloc(). Although there is no problem in Standard
|
||||
C, I've put in casts to keep C++ compilers happy.
|
||||
|
||||
3. Typo on pcretest.c; a cast of (unsigned char *) in the POSIX regexec() call
|
||||
should be (const char *).
|
||||
|
||||
4. If NOPOSIX is defined, pcretest.c compiles without POSIX support. This may
|
||||
be useful for non-Unix systems who don't want to bother with the POSIX stuff.
|
||||
However, I haven't made this a standard facility. The documentation doesn't
|
||||
mention it, and the Makefile doesn't support it.
|
||||
|
||||
5. The Makefile now contains an "install" target, with editable destinations at
|
||||
the top of the file. The pcretest program is not installed.
|
||||
|
||||
6. pgrep -V now gives the PCRE version number and date.
|
||||
|
||||
7. Fixed bug: a zero repetition after a literal string (e.g. /abcde{0}/) was
|
||||
causing the entire string to be ignored, instead of just the last character.
|
||||
|
||||
8. If a pattern like /"([^\\"]+|\\.)*"/ is applied in the normal way to a
|
||||
non-matching string, it can take a very, very long time, even for strings of
|
||||
quite modest length, because of the nested recursion. PCRE now does better in
|
||||
some of these cases. It does this by remembering the last required literal
|
||||
character in the pattern, and pre-searching the subject to ensure it is present
|
||||
before running the real match. In other words, it applies a heuristic to detect
|
||||
some types of certain failure quickly, and in the above example, if presented
|
||||
with a string that has no trailing " it gives "no match" very quickly.
|
||||
|
||||
9. A new runtime option PCRE_NOTEMPTY causes null string matches to be ignored;
|
||||
other alternatives are tried instead.
|
||||
|
||||
|
||||
Version 2.06 09-Jun-99
|
||||
----------------------
|
||||
|
||||
1. Change pcretest's output for amount of store used to show just the code
|
||||
space, because the remainder (the data block) varies in size between 32-bit and
|
||||
64-bit systems.
|
||||
|
||||
2. Added an extra argument to pcre_exec() to supply an offset in the subject to
|
||||
start matching at. This allows lookbehinds to work when searching for multiple
|
||||
occurrences in a string.
|
||||
|
||||
3. Added additional options to pcretest for testing multiple occurrences:
|
||||
|
||||
/+ outputs the rest of the string that follows a match
|
||||
/g loops for multiple occurrences, using the new startoffset argument
|
||||
/G loops for multiple occurrences by passing an incremented pointer
|
||||
|
||||
4. PCRE wasn't doing the "first character" optimization for patterns starting
|
||||
with \b or \B, though it was doing it for other lookbehind assertions. That is,
|
||||
it wasn't noticing that a match for a pattern such as /\bxyz/ has to start with
|
||||
the letter 'x'. On long subject strings, this gives a significant speed-up.
|
||||
|
||||
|
||||
Version 2.05 21-Apr-99
|
||||
----------------------
|
||||
|
||||
1. Changed the type of magic_number from int to long int so that it works
|
||||
properly on 16-bit systems.
|
||||
|
||||
2. Fixed a bug which caused patterns starting with .* not to work correctly
|
||||
when the subject string contained newline characters. PCRE was assuming
|
||||
anchoring for such patterns in all cases, which is not correct because .* will
|
||||
not pass a newline unless PCRE_DOTALL is set. It now assumes anchoring only if
|
||||
DOTALL is set at top level; otherwise it knows that patterns starting with .*
|
||||
must be retried after every newline in the subject.
|
||||
|
||||
|
||||
Version 2.04 18-Feb-99
|
||||
----------------------
|
||||
|
||||
1. For parenthesized subpatterns with repeats whose minimum was zero, the
|
||||
computation of the store needed to hold the pattern was incorrect (too large).
|
||||
If such patterns were nested a few deep, this could multiply and become a real
|
||||
problem.
|
||||
|
||||
2. Added /M option to pcretest to show the memory requirement of a specific
|
||||
pattern. Made -m a synonym of -s (which does this globally) for compatibility.
|
||||
|
||||
3. Subpatterns of the form (regex){n,m} (i.e. limited maximum) were being
|
||||
compiled in such a way that the backtracking after subsequent failure was
|
||||
pessimal. Something like (a){0,3} was compiled as (a)?(a)?(a)? instead of
|
||||
((a)((a)(a)?)?)? with disastrous performance if the maximum was of any size.
|
||||
|
||||
|
||||
Version 2.03 02-Feb-99
|
||||
----------------------
|
||||
|
||||
1. Fixed typo and small mistake in man page.
|
||||
|
||||
2. Added 4th condition (GPL supersedes if conflict) and created separate
|
||||
LICENCE file containing the conditions.
|
||||
|
||||
3. Updated pcretest so that patterns such as /abc\/def/ work like they do in
|
||||
Perl, that is the internal \ allows the delimiter to be included in the
|
||||
pattern. Locked out the use of \ as a delimiter. If \ immediately follows
|
||||
the final delimiter, add \ to the end of the pattern (to test the error).
|
||||
|
||||
4. Added the convenience functions for extracting substrings after a successful
|
||||
match. Updated pcretest to make it able to test these functions.
|
||||
|
||||
|
||||
Version 2.02 14-Jan-99
|
||||
----------------------
|
||||
|
||||
1. Initialized the working variables associated with each extraction so that
|
||||
their saving and restoring doesn't refer to uninitialized store.
|
||||
|
||||
2. Put dummy code into study.c in order to trick the optimizer of the IBM C
|
||||
compiler for OS/2 into generating correct code. Apparently IBM isn't going to
|
||||
fix the problem.
|
||||
|
||||
3. Pcretest: the timing code wasn't using LOOPREPEAT for timing execution
|
||||
calls, and wasn't printing the correct value for compiling calls. Increased the
|
||||
default value of LOOPREPEAT, and the number of significant figures in the
|
||||
times.
|
||||
|
||||
4. Changed "/bin/rm" in the Makefile to "-rm" so it works on Windows NT.
|
||||
|
||||
5. Renamed "deftables" as "dftables" to get it down to 8 characters, to avoid
|
||||
a building problem on Windows NT with a FAT file system.
|
||||
|
||||
|
||||
Version 2.01 21-Oct-98
|
||||
----------------------
|
||||
|
||||
1. Changed the API for pcre_compile() to allow for the provision of a pointer
|
||||
to character tables built by pcre_maketables() in the current locale. If NULL
|
||||
is passed, the default tables are used.
|
||||
|
||||
|
||||
Version 2.00 24-Sep-98
|
||||
----------------------
|
||||
|
||||
1. Since the (?>) facility is in Perl 5.005, don't require PCRE_EXTRA to enable
|
||||
it any more.
|
||||
|
||||
2. Allow quantification of (?>) groups, and make it work correctly.
|
||||
|
||||
3. The first character computation wasn't working for (?>) groups.
|
||||
|
||||
4. Correct the implementation of \Z (it is permitted to match on the \n at the
|
||||
end of the subject) and add 5.005's \z, which really does match only at the
|
||||
very end of the subject.
|
||||
|
||||
5. Remove the \X "cut" facility; Perl doesn't have it, and (?> is neater.
|
||||
|
||||
6. Remove the ability to specify CASELESS, MULTILINE, DOTALL, and
|
||||
DOLLAR_END_ONLY at runtime, to make it possible to implement the Perl 5.005
|
||||
localized options. All options to pcre_study() were also removed.
|
||||
|
||||
7. Add other new features from 5.005:
|
||||
|
||||
$(?<= positive lookbehind
|
||||
$(?<! negative lookbehind
|
||||
(?imsx-imsx) added the unsetting capability
|
||||
such a setting is global if at outer level; local otherwise
|
||||
(?imsx-imsx:) non-capturing groups with option setting
|
||||
(?(cond)re|re) conditional pattern matching
|
||||
|
||||
A backreference to itself in a repeated group matches the previous
|
||||
captured string.
|
||||
|
||||
8. General tidying up of studying (both automatic and via "study")
|
||||
consequential on the addition of new assertions.
|
||||
|
||||
9. As in 5.005, unlimited repeated groups that could match an empty substring
|
||||
are no longer faulted at compile time. Instead, the loop is forcibly broken at
|
||||
runtime if any iteration does actually match an empty substring.
|
||||
|
||||
10. Include the RunTest script in the distribution.
|
||||
|
||||
11. Added tests from the Perl 5.005_02 distribution. This showed up a few
|
||||
discrepancies, some of which were old and were also with respect to 5.004. They
|
||||
have now been fixed.
|
||||
|
||||
|
||||
Version 1.09 28-Apr-98
|
||||
----------------------
|
||||
|
||||
1. A negated single character class followed by a quantifier with a minimum
|
||||
value of one (e.g. [^x]{1,6} ) was not compiled correctly. This could lead to
|
||||
program crashes, or just wrong answers. This did not apply to negated classes
|
||||
containing more than one character, or to minima other than one.
|
||||
|
||||
|
||||
Version 1.08 27-Mar-98
|
||||
----------------------
|
||||
|
||||
1. Add PCRE_UNGREEDY to invert the greediness of quantifiers.
|
||||
|
||||
2. Add (?U) and (?X) to set PCRE_UNGREEDY and PCRE_EXTRA respectively. The
|
||||
latter must appear before anything that relies on it in the pattern.
|
||||
|
||||
|
||||
Version 1.07 16-Feb-98
|
||||
----------------------
|
||||
|
||||
1. A pattern such as /((a)*)*/ was not being diagnosed as in error (unlimited
|
||||
repeat of a potentially empty string).
|
||||
|
||||
|
||||
Version 1.06 23-Jan-98
|
||||
----------------------
|
||||
|
||||
1. Added Markus Oberhumer's little patches for C++.
|
||||
|
||||
2. Literal strings longer than 255 characters were broken.
|
||||
|
||||
|
||||
Version 1.05 23-Dec-97
|
||||
----------------------
|
||||
|
||||
1. Negated character classes containing more than one character were failing if
|
||||
PCRE_CASELESS was set at run time.
|
||||
|
||||
|
||||
Version 1.04 19-Dec-97
|
||||
----------------------
|
||||
|
||||
1. Corrected the man page, where some "const" qualifiers had been omitted.
|
||||
|
||||
2. Made debugging output print "{0,xxx}" instead of just "{,xxx}" to agree with
|
||||
input syntax.
|
||||
|
||||
3. Fixed memory leak which occurred when a regex with back references was
|
||||
matched with an offsets vector that wasn't big enough. The temporary memory
|
||||
that is used in this case wasn't being freed if the match failed.
|
||||
|
||||
4. Tidied pcretest to ensure it frees memory that it gets.
|
||||
|
||||
5. Temporary memory was being obtained in the case where the passed offsets
|
||||
vector was exactly big enough.
|
||||
|
||||
6. Corrected definition of offsetof() from change 5 below.
|
||||
|
||||
7. I had screwed up change 6 below and broken the rules for the use of
|
||||
setjmp(). Now fixed.
|
||||
|
||||
|
||||
Version 1.03 18-Dec-97
|
||||
----------------------
|
||||
|
||||
1. A erroneous regex with a missing opening parenthesis was correctly
|
||||
diagnosed, but PCRE attempted to access brastack[-1], which could cause crashes
|
||||
on some systems.
|
||||
|
||||
2. Replaced offsetof(real_pcre, code) by offsetof(real_pcre, code[0]) because
|
||||
it was reported that one broken compiler failed on the former because "code" is
|
||||
also an independent variable.
|
||||
|
||||
3. The erroneous regex a[]b caused an array overrun reference.
|
||||
|
||||
4. A regex ending with a one-character negative class (e.g. /[^k]$/) did not
|
||||
fail on data ending with that character. (It was going on too far, and checking
|
||||
the next character, typically a binary zero.) This was specific to the
|
||||
optimized code for single-character negative classes.
|
||||
|
||||
5. Added a contributed patch from the TIN world which does the following:
|
||||
|
||||
+ Add an undef for memmove, in case the the system defines a macro for it.
|
||||
|
||||
+ Add a definition of offsetof(), in case there isn't one. (I don't know
|
||||
the reason behind this - offsetof() is part of the ANSI standard - but
|
||||
it does no harm).
|
||||
|
||||
+ Reduce the ifdef's in pcre.c using macro DPRINTF, thereby eliminating
|
||||
most of the places where whitespace preceded '#'. I have given up and
|
||||
allowed the remaining 2 cases to be at the margin.
|
||||
|
||||
+ Rename some variables in pcre to eliminate shadowing. This seems very
|
||||
pedantic, but does no harm, of course.
|
||||
|
||||
6. Moved the call to setjmp() into its own function, to get rid of warnings
|
||||
from gcc -Wall, and avoided calling it at all unless PCRE_EXTRA is used.
|
||||
|
||||
7. Constructs such as \d{8,} were compiling into the equivalent of
|
||||
\d{8}\d{0,65527} instead of \d{8}\d* which didn't make much difference to the
|
||||
outcome, but in this particular case used more store than had been allocated,
|
||||
which caused the bug to be discovered because it threw up an internal error.
|
||||
|
||||
8. The debugging code in both pcre and pcretest for outputting the compiled
|
||||
form of a regex was going wrong in the case of back references followed by
|
||||
curly-bracketed repeats.
|
||||
|
||||
|
||||
Version 1.02 12-Dec-97
|
||||
----------------------
|
||||
|
||||
1. Typos in pcre.3 and comments in the source fixed.
|
||||
|
||||
2. Applied a contributed patch to get rid of places where it used to remove
|
||||
'const' from variables, and fixed some signed/unsigned and uninitialized
|
||||
variable warnings.
|
||||
|
||||
3. Added the "runtest" target to Makefile.
|
||||
|
||||
4. Set default compiler flag to -O2 rather than just -O.
|
||||
|
||||
|
||||
Version 1.01 19-Nov-97
|
||||
----------------------
|
||||
|
||||
1. PCRE was failing to diagnose unlimited repeat of empty string for patterns
|
||||
like /([ab]*)*/, that is, for classes with more than one character in them.
|
||||
|
||||
2. Likewise, it wasn't diagnosing patterns with "once-only" subpatterns, such
|
||||
as /((?>a*))*/ (a PCRE_EXTRA facility).
|
||||
|
||||
|
||||
Version 1.00 18-Nov-97
|
||||
----------------------
|
||||
|
||||
1. Added compile-time macros to support systems such as SunOS4 which don't have
|
||||
memmove() or strerror() but have other things that can be used instead.
|
||||
|
||||
2. Arranged that "make clean" removes the executables.
|
||||
|
||||
|
||||
Version 0.99 27-Oct-97
|
||||
----------------------
|
||||
|
||||
1. Fixed bug in code for optimizing classes with only one character. It was
|
||||
initializing a 32-byte map regardless, which could cause it to run off the end
|
||||
of the memory it had got.
|
||||
|
||||
2. Added, conditional on PCRE_EXTRA, the proposed (?>REGEX) construction.
|
||||
|
||||
|
||||
Version 0.98 22-Oct-97
|
||||
----------------------
|
||||
|
||||
1. Fixed bug in code for handling temporary memory usage when there are more
|
||||
back references than supplied space in the ovector. This could cause segfaults.
|
||||
|
||||
|
||||
Version 0.97 21-Oct-97
|
||||
----------------------
|
||||
|
||||
1. Added the \X "cut" facility, conditional on PCRE_EXTRA.
|
||||
|
||||
2. Optimized negated single characters not to use a bit map.
|
||||
|
||||
3. Brought error texts together as macro definitions; clarified some of them;
|
||||
fixed one that was wrong - it said "range out of order" when it meant "invalid
|
||||
escape sequence".
|
||||
|
||||
4. Changed some char * arguments to const char *.
|
||||
|
||||
5. Added PCRE_NOTBOL and PCRE_NOTEOL (from POSIX).
|
||||
|
||||
6. Added the POSIX-style API wrapper in pcreposix.a and testing facilities in
|
||||
pcretest.
|
||||
|
||||
|
||||
Version 0.96 16-Oct-97
|
||||
----------------------
|
||||
|
||||
1. Added a simple "pgrep" utility to the distribution.
|
||||
|
||||
2. Fixed an incompatibility with Perl: "{" is now treated as a normal character
|
||||
unless it appears in one of the precise forms "{ddd}", "{ddd,}", or "{ddd,ddd}"
|
||||
where "ddd" means "one or more decimal digits".
|
||||
|
||||
3. Fixed serious bug. If a pattern had a back reference, but the call to
|
||||
pcre_exec() didn't supply a large enough ovector to record the related
|
||||
identifying subpattern, the match always failed. PCRE now remembers the number
|
||||
of the largest back reference, and gets some temporary memory in which to save
|
||||
the offsets during matching if necessary, in order to ensure that
|
||||
backreferences always work.
|
||||
|
||||
4. Increased the compatibility with Perl in a number of ways:
|
||||
|
||||
(a) . no longer matches \n by default; an option PCRE_DOTALL is provided
|
||||
to request this handling. The option can be set at compile or exec time.
|
||||
|
||||
(b) $ matches before a terminating newline by default; an option
|
||||
PCRE_DOLLAR_ENDONLY is provided to override this (but not in multiline
|
||||
mode). The option can be set at compile or exec time.
|
||||
|
||||
(c) The handling of \ followed by a digit other than 0 is now supposed to be
|
||||
the same as Perl's. If the decimal number it represents is less than 10
|
||||
or there aren't that many previous left capturing parentheses, an octal
|
||||
escape is read. Inside a character class, it's always an octal escape,
|
||||
even if it is a single digit.
|
||||
|
||||
(d) An escaped but undefined alphabetic character is taken as a literal,
|
||||
unless PCRE_EXTRA is set. Currently this just reserves the remaining
|
||||
escapes.
|
||||
|
||||
(e) {0} is now permitted. (The previous item is removed from the compiled
|
||||
pattern).
|
||||
|
||||
5. Changed all the names of code files so that the basic parts are no longer
|
||||
than 10 characters, and abolished the teeny "globals.c" file.
|
||||
|
||||
6. Changed the handling of character classes; they are now done with a 32-byte
|
||||
bit map always.
|
||||
|
||||
7. Added the -d and /D options to pcretest to make it possible to look at the
|
||||
internals of compilation without having to recompile pcre.
|
||||
|
||||
|
||||
Version 0.95 23-Sep-97
|
||||
----------------------
|
||||
|
||||
1. Fixed bug in pre-pass concerning escaped "normal" characters such as \x5c or
|
||||
\x20 at the start of a run of normal characters. These were being treated as
|
||||
real characters, instead of the source characters being re-checked.
|
||||
|
||||
|
||||
Version 0.94 18-Sep-97
|
||||
----------------------
|
||||
|
||||
1. The functions are now thread-safe, with the caveat that the global variables
|
||||
containing pointers to malloc() and free() or alternative functions are the
|
||||
same for all threads.
|
||||
|
||||
2. Get pcre_study() to generate a bitmap of initial characters for non-
|
||||
anchored patterns when this is possible, and use it if passed to pcre_exec().
|
||||
|
||||
|
||||
Version 0.93 15-Sep-97
|
||||
----------------------
|
||||
|
||||
1. /(b)|(:+)/ was computing an incorrect first character.
|
||||
|
||||
2. Add pcre_study() to the API and the passing of pcre_extra to pcre_exec(),
|
||||
but not actually doing anything yet.
|
||||
|
||||
3. Treat "-" characters in classes that cannot be part of ranges as literals,
|
||||
as Perl does (e.g. [-az] or [az-]).
|
||||
|
||||
4. Set the anchored flag if a branch starts with .* or .*? because that tests
|
||||
all possible positions.
|
||||
|
||||
5. Split up into different modules to avoid including unneeded functions in a
|
||||
compiled binary. However, compile and exec are still in one module. The "study"
|
||||
function is split off.
|
||||
|
||||
6. The character tables are now in a separate module whose source is generated
|
||||
by an auxiliary program - but can then be edited by hand if required. There are
|
||||
now no calls to isalnum(), isspace(), isdigit(), isxdigit(), tolower() or
|
||||
toupper() in the code.
|
||||
|
||||
7. Turn the malloc/free funtions variables into pcre_malloc and pcre_free and
|
||||
make them global. Abolish the function for setting them, as the caller can now
|
||||
set them directly.
|
||||
|
||||
|
||||
Version 0.92 11-Sep-97
|
||||
----------------------
|
||||
|
||||
1. A repeat with a fixed maximum and a minimum of 1 for an ordinary character
|
||||
(e.g. /a{1,3}/) was broken (I mis-optimized it).
|
||||
|
||||
2. Caseless matching was not working in character classes if the characters in
|
||||
the pattern were in upper case.
|
||||
|
||||
3. Make ranges like [W-c] work in the same way as Perl for caseless matching.
|
||||
|
||||
4. Make PCRE_ANCHORED public and accept as a compile option.
|
||||
|
||||
5. Add an options word to pcre_exec() and accept PCRE_ANCHORED and
|
||||
PCRE_CASELESS at run time. Add escapes \A and \I to pcretest to cause it to
|
||||
pass them.
|
||||
|
||||
6. Give an error if bad option bits passed at compile or run time.
|
||||
|
||||
7. Add PCRE_MULTILINE at compile and exec time, and (?m) as well. Add \M to
|
||||
pcretest to cause it to pass that flag.
|
||||
|
||||
8. Add pcre_info(), to get the number of identifying subpatterns, the stored
|
||||
options, and the first character, if set.
|
||||
|
||||
9. Recognize C+ or C{n,m} where n >= 1 as providing a fixed starting character.
|
||||
|
||||
|
||||
Version 0.91 10-Sep-97
|
||||
----------------------
|
||||
|
||||
1. PCRE was failing to diagnose unlimited repeats of subpatterns that could
|
||||
match the empty string as in /(a*)*/. It was looping and ultimately crashing.
|
||||
|
||||
2. PCRE was looping on encountering an indefinitely repeated back reference to
|
||||
a subpattern that had matched an empty string, e.g. /(a|)\1*/. It now does what
|
||||
Perl does - treats the match as successful.
|
||||
|
||||
****
|
||||
@@ -0,0 +1,50 @@
|
||||
PCRE LICENCE
|
||||
------------
|
||||
|
||||
PCRE is a library of functions to support regular expressions whose syntax
|
||||
and semantics are as close as possible to those of the Perl 5 language.
|
||||
|
||||
Written by: Philip Hazel <ph10@cam.ac.uk>
|
||||
|
||||
University of Cambridge Computing Service,
|
||||
Cambridge, England. Phone: +44 1223 334714.
|
||||
|
||||
Copyright (c) 1997-2000 University of Cambridge
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose on any
|
||||
computer system, and to redistribute it freely, subject to the following
|
||||
restrictions:
|
||||
|
||||
1. This software is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
|
||||
2. The origin of this software must not be misrepresented, either by
|
||||
explicit claim or by omission. In practice, this means that if you use
|
||||
PCRE in software which you distribute to others, commercially or
|
||||
otherwise, you must put a sentence like this
|
||||
|
||||
Regular expression support is provided by the PCRE library package,
|
||||
which is open source software, written by Philip Hazel, and copyright
|
||||
by the University of Cambridge, England.
|
||||
|
||||
somewhere reasonably visible in your documentation and in any relevant
|
||||
files or online help data or similar. A reference to the ftp site for
|
||||
the source, that is, to
|
||||
|
||||
ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/
|
||||
|
||||
should also be given in the documentation.
|
||||
|
||||
3. Altered versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
|
||||
4. If PCRE is embedded in any software that is released under the GNU
|
||||
General Purpose Licence (GPL), or Lesser General Purpose Licence (LGPL),
|
||||
then the terms of that licence shall supersede any condition above with
|
||||
which it is incompatible.
|
||||
|
||||
The documentation for PCRE, supplied in the "doc" directory, is distributed
|
||||
under the same terms as the software itself.
|
||||
|
||||
End
|
||||
@@ -0,0 +1,17 @@
|
||||
## Process this file with automake to produce Makefile.in
|
||||
|
||||
noinst_LIBRARIES = libpcre.a
|
||||
noinst_HEADERS = internal.h pcre.h regexp.h
|
||||
noinst_PROGRAMS = @PCREGREP@
|
||||
EXTRA_PROGRAMS = pcregrep
|
||||
EXTRA_DIST = AUTHORS ChangeLog ChangeLog.pre-sed LICENCE README regcomp.c
|
||||
|
||||
libpcre_a_SOURCES = regtables.c regsub.c regstudy.c regposix.c regperl.c \
|
||||
reginfo.c regexec.c regexp.c regdebug.c
|
||||
|
||||
INCLUDES = -I$(top_srcdir)/lib -I$(top_srcdir)/intl -I$(top_srcdir)/pcre \
|
||||
-I$(top_srcdir)
|
||||
|
||||
pcregrep_SOURCES = pcregrep.c
|
||||
pcregrep_LDADD = libpcre.a
|
||||
|
||||
+325
@@ -0,0 +1,325 @@
|
||||
README file for PCRE (Perl-compatible regular expression library)
|
||||
-----------------------------------------------------------------
|
||||
|
||||
The latest release of PCRE is always available from
|
||||
|
||||
ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre-xxx.tar.gz
|
||||
|
||||
Note that PCRE as included in super-sed is quite different from the
|
||||
original. The implementation has been split into more files, and
|
||||
internationalized; a POSIX regular expression parser was added (which in
|
||||
turn meant adding a few opcodes to the matcher), UTF-8 support was
|
||||
removed, and patterns with embedded nuls were supported. This is what
|
||||
will make a version lifted from the site and merged tout-court fail with
|
||||
100% probability. In addition, the POSIX expression parser has a special
|
||||
optimization that is turned on by expressions like "\n$" (in general,
|
||||
expression with a definite maximum length and anchored to the end of
|
||||
the pattern), which makes the matcher skip non-relevant parts of the
|
||||
subject and leap to its end.
|
||||
|
||||
PCRE has its own native API, but a set of "wrapper" functions that are based on
|
||||
the POSIX API are also supplied in the library. Note that this still provides
|
||||
the ability to use Perl semantics for regular expressions through a non-POSIX
|
||||
option flag, REG_PERL. The definition of REG_PERL is a good way to check if
|
||||
the POSIX API for regular expression is actually PCRE's implementation.
|
||||
|
||||
The header file for the POSIX-style functions is called regexp.h. The official
|
||||
POSIX name is regex.h, but I didn't want to risk possible problems with
|
||||
existing files of that name by distributing it that way. To use it with an
|
||||
existing program that uses the POSIX API, it will have to be renamed or
|
||||
pointed at by a link. You will obtain PCRE's behavior and speed, but not Perl
|
||||
semantics unless you modify the program to use REG_PERL.
|
||||
|
||||
|
||||
Technical Notes about PCRE
|
||||
--------------------------
|
||||
|
||||
Many years ago I implemented some regular expression functions to an algorithm
|
||||
suggested by Martin Richards. These were not Unix-like in form, and were quite
|
||||
restricted in what they could do by comparison with Perl. The interesting part
|
||||
about the algorithm was that the amount of space required to hold the compiled
|
||||
form of an expression was known in advance. The code to apply an expression did
|
||||
not operate by backtracking, as the Henry Spencer and Perl code does, but
|
||||
instead checked all possibilities simultaneously by keeping a list of current
|
||||
states and checking all of them as it advanced through the subject string. (In
|
||||
the terminology of Jeffrey Friedl's book, it was a "DFA algorithm".) When the
|
||||
pattern was all used up, all remaining states were possible matches, and the
|
||||
one matching the longest subset of the subject string was chosen. This did not
|
||||
necessarily maximize the individual wild portions of the pattern, as is
|
||||
expected in Unix and Perl-style regular expressions.
|
||||
|
||||
By contrast, the code originally written by Henry Spencer and subsequently
|
||||
heavily modified for Perl actually compiles the expression twice: once in a
|
||||
dummy mode in order to find out how much store will be needed, and then for
|
||||
real. The execution function operates by backtracking and maximizing (or,
|
||||
optionally, minimizing in Perl) the amount of the subject that matches
|
||||
individual wild portions of the pattern. This is an "NFA algorithm" in Friedl's
|
||||
terminology.
|
||||
|
||||
For the set of functions that forms PCRE (which are unrelated to those
|
||||
mentioned above), I tried at first to invent an algorithm that used an amount
|
||||
of store bounded by a multiple of the number of characters in the pattern, to
|
||||
save on compiling time. However, because of the greater complexity in Perl
|
||||
regular expressions, I couldn't do this. In any case, a first pass through the
|
||||
pattern is needed, in order to find internal flag settings like (?i) at top
|
||||
level. So PCRE works by running a very degenerate first pass to calculate a
|
||||
maximum store size, and then a second pass to do the real compile - which may
|
||||
use a bit less than the predicted amount of store. The idea is that this is
|
||||
going to turn out faster because the first pass is degenerate and the second
|
||||
pass can just store stuff straight into the vector. It does make the compiling
|
||||
functions bigger, of course, but they have got quite big anyway to handle all
|
||||
the Perl stuff.
|
||||
|
||||
The compiled form of a pattern is a vector of bytes, containing items of
|
||||
variable length. The first byte in an item is an opcode, and the length of the
|
||||
item is either implicit in the opcode or contained in the data bytes which
|
||||
follow it. A list of all the opcodes follows:
|
||||
|
||||
Opcodes with no following data
|
||||
------------------------------
|
||||
|
||||
These items are all just one byte long
|
||||
|
||||
OP_END end of pattern
|
||||
OP_ANY match any character
|
||||
OP_SOD match start of data: \A
|
||||
OP_CIRC ^ (start of data, or after \n in multiline)
|
||||
OP_NOT_WORD_BOUNDARY \W
|
||||
OP_WORD_BOUNDARY \w
|
||||
OP_EODN match end of data or \n at end: \Z
|
||||
OP_EOD match end of data: \z
|
||||
OP_DOLL $ (end of data, or before \n in multiline)
|
||||
OP_RECURSE match the pattern recursively
|
||||
|
||||
|
||||
Repeating single characters
|
||||
---------------------------
|
||||
|
||||
The common repeats (*, +, ?) when applied to a single character appear as
|
||||
two-byte items using the following opcodes:
|
||||
|
||||
OP_MAXSTAR
|
||||
OP_MINSTAR
|
||||
OP_ONCESTAR
|
||||
OP_MAXPLUS
|
||||
OP_MINPLUS
|
||||
OP_ONCEPLUS
|
||||
OP_MAXQUERY
|
||||
OP_MINQUERY
|
||||
OP_ONCEQUERY
|
||||
|
||||
Those with "MIN" in their name are the minimizing versions; those with ONCE
|
||||
instead are maximizing but do not do backtracking. Each is followed by
|
||||
the character that is to be repeated. Other repeats make use of
|
||||
|
||||
OP_MAXUPTO
|
||||
OP_MINUPTO
|
||||
OP_ONCEUPTO
|
||||
OP_EXACT
|
||||
|
||||
which are followed by a two-byte count (most significant first) and the
|
||||
repeated character. OP_*UPTO matches from 0 to the given number. A repeat with a
|
||||
non-zero minimum and a fixed maximum is coded as an OP_EXACT followed by an
|
||||
OP_*UPTO.
|
||||
|
||||
|
||||
Character types
|
||||
---------------
|
||||
|
||||
Things like \d, both repeated and not, are done exactly like repeated characters,
|
||||
except that instead of a character, the opcode for the type is stored in the data
|
||||
byte: 0 matches no character (all characters when negated), 1 matches digits,
|
||||
2 matches whitespace, 3 matches word characters. The opcodes are:
|
||||
|
||||
OP_TYPE OP_TYPENOT
|
||||
OP_TYPE_MAXSTAR OP_TYPENOT_MAXSTAR
|
||||
OP_TYPE_MINSTAR OP_TYPENOT_MINSTAR
|
||||
OP_TYPE_ONCESTAR OP_TYPENOT_ONCESTAR
|
||||
OP_TYPE_MAXPLUS OP_TYPENOT_MAXPLUS
|
||||
OP_TYPE_MINPLUS OP_TYPENOT_MINPLUS
|
||||
OP_TYPE_ONCEPLUS OP_TYPENOT_ONCEPLUS
|
||||
OP_TYPE_MAXQUERY OP_TYPENOT_MAXQUERY
|
||||
OP_TYPE_MINQUERY OP_TYPENOT_MINQUERY
|
||||
OP_TYPE_ONCEQUERY OP_TYPENOT_ONCEQUERY
|
||||
OP_TYPE_MAXUPTO OP_TYPENOT_MAXUPTO
|
||||
OP_TYPE_MINUPTO OP_TYPENOT_MINUPTO
|
||||
OP_TYPE_ONCEUPTO OP_TYPENOT_ONCEUPTO
|
||||
OP_TYPE_EXACT OP_TYPENOT_EXACT
|
||||
|
||||
The opcodes on the first line are the two that do not handle backtracking nor
|
||||
repeats.
|
||||
|
||||
Matching a character string
|
||||
---------------------------
|
||||
|
||||
The OP_CHARS opcode is followed by a one-byte count and then that number of
|
||||
characters. If there are more than 255 characters in sequence, successive
|
||||
instances of OP_CHARS are used.
|
||||
|
||||
|
||||
Character classes
|
||||
-----------------
|
||||
|
||||
OP_CLASS is used for a character class, provided there are at least two
|
||||
characters in the class. If there is only one character, OP_CHARS is used for a
|
||||
positive class, and OP_NOT for a negative one (that is, for something like
|
||||
[^a]). Another set of repeating opcodes (OP_NOT_MAXSTAR etc.) are used for a
|
||||
repeated, negated, single-character class. The normal ones (OP_MAXSTAR etc.)
|
||||
are used for a repeated positive single-character class.
|
||||
|
||||
OP_CLASS is followed by a 32-byte bit map containing a 1 bit for every
|
||||
character that is acceptable. The bits are counted from the least significant
|
||||
end of each byte.
|
||||
|
||||
|
||||
Back references
|
||||
---------------
|
||||
|
||||
OP_REF is followed by two bytes containing the reference number.
|
||||
|
||||
|
||||
Repeating character classes and back references
|
||||
-----------------------------------------------
|
||||
|
||||
This applies to OP_CLASS and OP_REF. For generic ranges (not + * ?) we use a
|
||||
single "RANGE" opcode instead of the UPTO+EXACT combination: these are
|
||||
|
||||
OP_CL_MAXRANGE
|
||||
OP_CL_MINRANGE
|
||||
OP_CL_ONCERANGE
|
||||
OP_REF_MAXRANGE
|
||||
OP_REF_MINRANGE
|
||||
OP_REF_ONCERANGE
|
||||
|
||||
and are followed by four bytes of data, comprising the minimum and maximum
|
||||
repeat counts.
|
||||
|
||||
Single-character classes are handled specially (see above).
|
||||
|
||||
|
||||
Brackets and alternation
|
||||
------------------------
|
||||
|
||||
A pair of non-capturing (round) brackets is wrapped round each expression at
|
||||
compile time, so alternation always happens in the context of brackets.
|
||||
|
||||
Non-capturing brackets use the opcode OP_BRA, while capturing brackets use
|
||||
OP_BRA+1, OP_BRA+2, etc. [Note for North Americans: "bracket" to some English
|
||||
speakers, including myself, can be round, square, curly, or pointy. Hence this
|
||||
usage.]
|
||||
|
||||
Originally PCRE was limited to 99 capturing brackets (so as not to use up all
|
||||
the opcodes). From release 3.5, there is no limit. What happens is that the
|
||||
first ones, up to EXTRACT_BASIC_MAX are handled with separate opcodes, as
|
||||
above. If there are more, the opcode is set to EXTRACT_BASIC_MAX+1, and the
|
||||
first operation in the bracket is OP_BRANUMBER, followed by a 2-byte bracket
|
||||
number. This opcode is ignored while matching, but is fished out when handling
|
||||
the bracket itself. (They could have all been done like this, but I was making
|
||||
minimal changes.)
|
||||
|
||||
A bracket opcode is followed by two bytes which give the offset to the next
|
||||
alternative OP_ALT or, if there aren't any branches, to the matching KET
|
||||
opcode. Each OP_ALT is followed by two bytes giving the offset to the next one,
|
||||
or to the KET opcode.
|
||||
|
||||
OP_KET is used for subpatterns that do not repeat indefinitely, while
|
||||
OP_KET_MINSTAR, OP_KET_MAXSTAR and OP_KET_ONCESTAR are used for indefinite
|
||||
repetitions, minimally or maximally respectively. All three are followed by
|
||||
two bytes giving (as a positive number) the offset back to the matching BRA
|
||||
opcode.
|
||||
|
||||
If a subpattern is quantified such that it is permitted to match zero times, it
|
||||
is preceded by one of OP_BRAZERO or OP_BRAMINZERO. These are single-byte
|
||||
opcodes which tell the matcher that skipping this subpattern entirely is a
|
||||
valid branch.
|
||||
|
||||
A subpattern with an indefinite maximum repetition is replicated in the
|
||||
compiled data its minimum number of times (or once with a BRAZERO if the
|
||||
minimum is zero), with the final copy terminating with a KETRMIN or KETRMAX as
|
||||
appropriate.
|
||||
|
||||
A subpattern with a bounded maximum repetition is replicated in a nested
|
||||
fashion up to the maximum number of times, with BRAZERO or BRAMINZERO before
|
||||
each replication after the minimum, so that, for example, (abc){2,5} is
|
||||
compiled as (abc)(abc)((abc)((abc)(abc)?)?)?. The 99 and 200 bracket limits do
|
||||
not apply to these internally generated brackets.
|
||||
|
||||
|
||||
Assertions
|
||||
----------
|
||||
|
||||
Forward assertions are just like other subpatterns, but starting with one of
|
||||
the opcodes OP_ASSERT or OP_ASSERT_NOT. Backward assertions use the opcodes
|
||||
OP_ASSERTBACK and OP_ASSERTBACK_NOT, and the first opcode inside the assertion
|
||||
is OP_REVERSE, followed by a two byte count of the number of characters to move
|
||||
back the pointer in the subject string. A separate count is present in each
|
||||
alternative of a lookbehind assertion, allowing them to have different
|
||||
fixed lengths.
|
||||
|
||||
|
||||
Once-only subpatterns
|
||||
---------------------
|
||||
|
||||
These are also just like other subpatterns, but they start with the opcode
|
||||
OP_ONCE.
|
||||
|
||||
|
||||
Conditional subpatterns
|
||||
-----------------------
|
||||
|
||||
These are like other subpatterns, but they start with the opcode OP_COND. If
|
||||
the condition is a back reference, this is stored at the start of the
|
||||
subpattern using the opcode OP_CREF followed by two bytes containing the
|
||||
reference number. Otherwise, a conditional subpattern will always start with
|
||||
one of the assertions.
|
||||
|
||||
|
||||
Changing options
|
||||
----------------
|
||||
|
||||
If any of the /i, /m, or /s options are changed within a parenthesized group,
|
||||
an OP_OPT opcode is compiled, followed by one byte containing the new settings
|
||||
of these flags. If there are several alternatives in a group, there is an
|
||||
occurrence of OP_OPT at the start of all those following the first options
|
||||
change, to set appropriate options for the start of the alternative.
|
||||
Immediately after the end of the group there is another such item to reset the
|
||||
flags to their previous values. Other changes of flag within the pattern can be
|
||||
handled entirely at compile time, and so do not cause anything to be put into
|
||||
the compiled data.
|
||||
|
||||
|
||||
Character tables
|
||||
----------------
|
||||
|
||||
PCRE uses four tables for manipulating and identifying characters. The final
|
||||
argument of the pcre_*compile*() functions is a pointer to a block of memory
|
||||
containing the concatenated tables. A call to pcre_maketables() can be used to
|
||||
generate a set of tables in the current locale. If the final argument for
|
||||
pcre_*_compile*() is passed as NULL, a set of default tables that is built into
|
||||
the binary is used.
|
||||
|
||||
The first two 256-byte tables provide lower casing and case flipping functions,
|
||||
respectively. The next table consists of many 32-byte bit maps which identify
|
||||
digits, "word" characters, white space, and so on. These are used when
|
||||
building 32-byte bit maps that represent character classes.
|
||||
|
||||
The final 256-byte table has bits indicating various character types, as
|
||||
follows:
|
||||
|
||||
1 newline
|
||||
2 decimal digit
|
||||
4 white space character
|
||||
8 alphanumeric or '_'
|
||||
16 letter
|
||||
32 hexadecimal digit
|
||||
128 regular expression metacharacter or binary zero
|
||||
|
||||
You should not alter the set of characters that contain the 128 bit, as that
|
||||
will cause PCRE to malfunction.
|
||||
|
||||
Philip Hazel <ph10@cam.ac.uk>
|
||||
October 2001
|
||||
|
||||
modified by
|
||||
Paolo Bonzini <bonzini@gnu.org>
|
||||
January 2002
|
||||
+447
@@ -0,0 +1,447 @@
|
||||
/*************************************************
|
||||
* Perl-Compatible Regular Expressions *
|
||||
*************************************************/
|
||||
|
||||
|
||||
/* This is a library of functions to support regular expressions whose syntax
|
||||
and semantics are as close as possible to those of the Perl 5 language. See
|
||||
the file Tech.Notes for some information on the internals.
|
||||
|
||||
Written by: Philip Hazel <ph10@cam.ac.uk>
|
||||
|
||||
Copyright (c) 1997-2000 University of Cambridge
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
Permission is granted to anyone to use this software for any purpose on any
|
||||
computer system, and to redistribute it freely, subject to the following
|
||||
restrictions:
|
||||
|
||||
1. This software is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
|
||||
2. The origin of this software must not be misrepresented, either by
|
||||
explicit claim or by omission.
|
||||
|
||||
3. Altered versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
|
||||
4. If PCRE is embedded in any software that is released under the GNU
|
||||
General Purpose Licence (GPL), then the terms of that licence shall
|
||||
supersede any condition above with which it is incompatible.
|
||||
-----------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#ifndef PCRE_INTERNAL_H
|
||||
#define PCRE_INTERNAL_H
|
||||
|
||||
/* This header contains definitions that are shared between the different
|
||||
modules, but which are not relevant to the outside. */
|
||||
|
||||
/* Get the definitions provided by running "configure" */
|
||||
|
||||
#include "config.h"
|
||||
|
||||
/* #define DEBUG */
|
||||
|
||||
/* Standard C headers plus the external interface definition */
|
||||
|
||||
#include "basicdefs.h"
|
||||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#ifdef HAVE_STDDEF_H
|
||||
# include <stddef.h>
|
||||
#endif
|
||||
#ifdef STDC_HEADERS
|
||||
# include <stdlib.h>
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_STRING_H
|
||||
# include <string.h>
|
||||
#else
|
||||
# include <strings.h>
|
||||
#endif
|
||||
#ifdef HAVE_MEMORY_H
|
||||
# include <memory.h>
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_STRCHR
|
||||
# define strchr index
|
||||
# define strrchr rindex
|
||||
#endif
|
||||
|
||||
#include "pcre.h"
|
||||
|
||||
#ifdef HAVE_LIMITS_H
|
||||
#include <limits.h>
|
||||
#else
|
||||
#define INT_MAX ((1L<<30)-1+(1L<<30))
|
||||
#define INT_MIN (-(1L<<30)-(1L<<30))
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_MEMSET
|
||||
#define memset(s, better_be_zero, n) (better_be_zero ? abort() : bzero(s, n))
|
||||
#endif
|
||||
|
||||
/* In case there is no definition of offsetof() provided - though any proper
|
||||
Standard C system should have one. */
|
||||
|
||||
#ifndef offsetof
|
||||
#define offsetof(p_type,field) ((size_t)&(((p_type *)0)->field))
|
||||
#endif
|
||||
|
||||
/* These are the public options that can change during matching. */
|
||||
|
||||
#define PCRE_IMS (PCRE_CASELESS|PCRE_MULTILINE|PCRE_DOTALL)
|
||||
|
||||
/* Private options flags start at the most significant end of the four bytes,
|
||||
but skip the top bit so we can use ints for convenience without getting tangled
|
||||
with negative values. The public options defined in pcre.h start at the least
|
||||
significant end. Make sure they don't overlap, though now that we have expanded
|
||||
to four bytes there is plenty of space. */
|
||||
|
||||
#define PCRE_FIRSTSET 0x40000000 /* first_char is set */
|
||||
#define PCRE_REQCHSET 0x20000000 /* req_char is set */
|
||||
#define PCRE_STARTLINE 0x10000000 /* start after \n for multiline */
|
||||
#define PCRE_INGROUP 0x08000000 /* compiling inside a group */
|
||||
#define PCRE_ICHANGED 0x04000000 /* i option changes within regex */
|
||||
|
||||
/* Options for the "extra" block produced by pcre_study(). */
|
||||
|
||||
#define PCRE_STUDY_MAPPED 0x01 /* a map of starting chars exists */
|
||||
#define PCRE_STUDY_BM 0x02 /* a Boyer-Moore map exists */
|
||||
|
||||
/* Masks for identifying the public options which are permitted at compile
|
||||
time, run time or study time, respectively. */
|
||||
|
||||
#define PUBLIC_OPTIONS \
|
||||
(PCRE_CASELESS|PCRE_EXTENDED|PCRE_ANCHORED|PCRE_MULTILINE| \
|
||||
PCRE_DOTALL|PCRE_DOLLAR_ENDONLY|PCRE_EXTRA|PCRE_UNGREEDY| \
|
||||
PCRE_ENGLISH_ERRORS)
|
||||
|
||||
#define PUBLIC_EXEC_OPTIONS \
|
||||
(PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY)
|
||||
|
||||
#define PUBLIC_STUDY_OPTIONS \
|
||||
(PCRE_STUDY_NO_PRUNE|PCRE_STUDY_NO_START)
|
||||
|
||||
/* Magic number to provide a small check against being handed junk. */
|
||||
|
||||
#define MAGIC_NUMBER 0x50435245UL /* 'PCRE' */
|
||||
|
||||
/* Miscellaneous definitions */
|
||||
|
||||
typedef int BOOL;
|
||||
|
||||
#define FALSE 0
|
||||
#define TRUE 1
|
||||
|
||||
/* These are escaped items that aren't just an encoding of a particular data
|
||||
value such as \n. They must have non-zero values, as check_escape() returns
|
||||
their negation. Also, they must appear in the same order as in the opcode
|
||||
definitions below, up to ESC_z. The final one must be ESC_REF as subsequent
|
||||
values are used for \1, \2, \3, etc. */
|
||||
|
||||
enum
|
||||
{
|
||||
ESC_LESS = 1, ESC_GREATER,
|
||||
ESC_G, ESC_B, ESC_b,
|
||||
ESC_A, ESC_Z, ESC_z,
|
||||
ESC_D, ESC_d, ESC_S, ESC_s, ESC_W, ESC_w,
|
||||
ESC_FIRST_CONSUME = ESC_D,
|
||||
ESC_LAST_CONSUME = ESC_w,
|
||||
ESC_REF,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
KIND_MAX, KIND_MIN, KIND_ONCE
|
||||
};
|
||||
|
||||
/* Opcode table: OP_BRA must be last, as all values >= it are used for brackets
|
||||
that extract substrings. Starting from 1 (i.e. after OP_END), the values up to
|
||||
OP_EOD must correspond in order to the list of escapes immediately above. */
|
||||
|
||||
enum
|
||||
{
|
||||
OP_END, /* End of pattern */
|
||||
|
||||
/* Values corresponding to backslashed assertions */
|
||||
|
||||
OP_BEG_WORD, /* \< */
|
||||
OP_END_WORD, /* \> */
|
||||
OP_ANCHOR_MATCH, /* \G */
|
||||
OP_NOT_WORD_BOUNDARY, /* \B */
|
||||
OP_WORD_BOUNDARY, /* \b */
|
||||
OP_SOD, /* Start of data: \A */
|
||||
OP_EODN, /* End of data or \n at end of data: \Z. */
|
||||
OP_EOD, /* End of data: \z */
|
||||
|
||||
OP_OPT, /* Set runtime options */
|
||||
OP_CIRC, /* Start of line - varies with multiline switch */
|
||||
OP_DOLL, /* End of line - varies with multiline switch */
|
||||
OP_ANY, /* Match any character */
|
||||
|
||||
OP_CHARS, /* Match string of characters */
|
||||
OP_MAXSTAR, /* The maximizing and minimizing versions of */
|
||||
OP_MINSTAR, /* all these opcodes must come in triples, with */
|
||||
OP_ONCESTAR, /* the minimizing one second and the */
|
||||
OP_MAXPLUS, /* no-backtracking one third. */
|
||||
OP_MINPLUS, /* This first set applies to single characters */
|
||||
OP_ONCEPLUS,
|
||||
OP_MAXQUERY,
|
||||
OP_MINQUERY,
|
||||
OP_ONCEQUERY,
|
||||
OP_MAXUPTO, /* From 0 to n matches */
|
||||
OP_MINUPTO,
|
||||
OP_ONCEUPTO,
|
||||
OP_EXACT,
|
||||
|
||||
OP_NOT, /* Match anything but the following char */
|
||||
OP_NOT_MAXSTAR, /* The maximizing and minimizing versions of */
|
||||
OP_NOT_MINSTAR, /* all these opcodes must come in triples, with */
|
||||
OP_NOT_ONCESTAR, /* the minimizing one second and the */
|
||||
OP_NOT_MAXPLUS, /* no-backtracking one third. */
|
||||
OP_NOT_MINPLUS, /* This set applies to "not" single characters */
|
||||
OP_NOT_ONCEPLUS,
|
||||
OP_NOT_MAXQUERY,
|
||||
OP_NOT_MINQUERY,
|
||||
OP_NOT_ONCEQUERY,
|
||||
OP_NOT_MAXUPTO, /* From 0 to n matches */
|
||||
OP_NOT_MINUPTO,
|
||||
OP_NOT_ONCEUPTO,
|
||||
OP_NOTEXACT, /* Exactly n matches */
|
||||
|
||||
OP_TYPE,
|
||||
OP_TYPE_MAXSTAR, /* The maximizing and minimizing versions of */
|
||||
OP_TYPE_MINSTAR, /* all these opcodes must come in triples, with */
|
||||
OP_TYPE_ONCESTAR, /* the minimizing one second and the */
|
||||
OP_TYPE_MAXPLUS, /* no-backtracking one third. These codes must */
|
||||
OP_TYPE_MINPLUS, /* be in exactly the same order as those above. */
|
||||
OP_TYPE_ONCEPLUS,
|
||||
OP_TYPE_MAXQUERY, /* This set applies to character types such as \d */
|
||||
OP_TYPE_MINQUERY,
|
||||
OP_TYPE_ONCEQUERY,
|
||||
OP_TYPE_MAXUPTO, /* From 0 to n matches */
|
||||
OP_TYPE_MINUPTO,
|
||||
OP_TYPE_ONCEUPTO,
|
||||
OP_TYPEEXACT, /* Exactly n matches */
|
||||
|
||||
OP_TYPENOT,
|
||||
OP_TYPENOT_MAXSTAR, /* The maximizing and minimizing versions of */
|
||||
OP_TYPENOT_MINSTAR, /* all these opcodes must come in triples, with */
|
||||
OP_TYPENOT_ONCESTAR, /* the minimizing one second and the */
|
||||
OP_TYPENOT_MAXPLUS, /* no-backtracking one third. These codes must */
|
||||
OP_TYPENOT_MINPLUS, /* be in exactly the same order as those above. */
|
||||
OP_TYPENOT_ONCEPLUS,
|
||||
OP_TYPENOT_MAXQUERY, /* This set applies to character types such as \D */
|
||||
OP_TYPENOT_MINQUERY,
|
||||
OP_TYPENOT_ONCEQUERY,
|
||||
OP_TYPENOT_MAXUPTO, /* From 0 to n matches */
|
||||
OP_TYPENOT_MINUPTO,
|
||||
OP_TYPENOT_ONCEUPTO,
|
||||
OP_TYPENOTEXACT, /* Exactly n matches */
|
||||
|
||||
OP_CLASS, /* Match a character class */
|
||||
OP_CL_MAXSTAR, /* The maximizing and minimizing versions of */
|
||||
OP_CL_MINSTAR, /* all these opcodes must come in pairs, with */
|
||||
OP_CL_ONCESTAR, /* the minimizing one second and the */
|
||||
OP_CL_MAXPLUS, /* no-backtracking one third. These codes must */
|
||||
OP_CL_MINPLUS, /* be in exactly the same order as those above. */
|
||||
OP_CL_ONCEPLUS,
|
||||
OP_CL_MAXQUERY, /* These are for character classes */
|
||||
OP_CL_MINQUERY,
|
||||
OP_CL_ONCEQUERY,
|
||||
OP_CL_MAXRANGE, /* These are different to the three seta above. */
|
||||
OP_CL_MINRANGE,
|
||||
OP_CL_ONCERANGE,
|
||||
|
||||
OP_REF, /* Match a back reference */
|
||||
OP_REF_MAXSTAR, /* The maximizing and minimizing versions of */
|
||||
OP_REF_MINSTAR, /* all these opcodes must come in pairs, with */
|
||||
OP_REF_ONCESTAR, /* the minimizing one second and the */
|
||||
OP_REF_MAXPLUS, /* no-backtracking one third. These codes must */
|
||||
OP_REF_MINPLUS, /* be in exactly the same order as those above. */
|
||||
OP_REF_ONCEPLUS,
|
||||
OP_REF_MAXQUERY, /* These are for character classes */
|
||||
OP_REF_MINQUERY,
|
||||
OP_REF_ONCEQUERY,
|
||||
OP_REF_MAXRANGE, /* These are different to the three seta above. */
|
||||
OP_REF_MINRANGE,
|
||||
OP_REF_ONCERANGE,
|
||||
|
||||
OP_RECURSE, /* Match this pattern recursively */
|
||||
|
||||
OP_ALT, /* Start of alternation */
|
||||
OP_KET, /* End of group that doesn't have an unbounded repeat */
|
||||
OP_KET_MAXSTAR, /* These three must remain together and in this */
|
||||
OP_KET_MINSTAR, /* order. They are for groups the repeat for ever. */
|
||||
OP_KET_ONCESTAR,
|
||||
|
||||
/* The assertions must come before ONCE and COND */
|
||||
|
||||
OP_ASSERT, /* Positive lookahead */
|
||||
OP_ASSERT_NOT, /* Negative lookahead */
|
||||
OP_ASSERTBACK, /* Positive lookbehind */
|
||||
OP_ASSERTBACK_NOT, /* Negative lookbehind */
|
||||
OP_REVERSE, /* Move pointer back - used in lookbehind assertions */
|
||||
|
||||
/* ONCE and COND must come after the assertions, with ONCE first, as there's
|
||||
a test for >= ONCE for a subpattern that isn't an assertion. */
|
||||
|
||||
OP_ONCE, /* Once matched, don't back up into the subpattern */
|
||||
OP_COND, /* Conditional group */
|
||||
OP_CREF, /* Used to hold an extraction string number (cond ref) */
|
||||
|
||||
OP_BRAZERO, /* These two must remain together and in this */
|
||||
OP_BRAMINZERO, /* order. */
|
||||
|
||||
OP_BRANUMBER, /* Used for extracting brackets whose number is greater
|
||||
than can fit into an opcode. */
|
||||
|
||||
OP_BRA /* This and greater values are used for brackets that
|
||||
extract substrings up to a basic limit. After that,
|
||||
use is made of OP_BRANUMBER. */
|
||||
};
|
||||
|
||||
/* The highest extraction number. This is limited by the number of opcodes
|
||||
left after OP_BRA, i.e. 255 - OP_BRA. We actually set it somewhat lower
|
||||
to leave room for additional opcodes.. */
|
||||
|
||||
#define EXTRACT_BASIC_MAX 150
|
||||
|
||||
/* The texts of compile-time error messages are defined as macros here so that
|
||||
they can be accessed by the POSIX wrapper and converted into error codes. Yes,
|
||||
I could have used error codes in the first place, but didn't feel like changing
|
||||
just to accommodate the POSIX wrapper. */
|
||||
|
||||
|
||||
/* All character handling must be done as unsigned characters. Otherwise there
|
||||
are problems with top-bit-set characters and functions such as isspace().
|
||||
However, we leave the interface to the outside world as char *, because that
|
||||
should make things easier for callers. We define a short type for unsigned char
|
||||
to save lots of typing. I tried "uchar", but it causes problems on Digital
|
||||
Unix, where it is defined in sys/types, so use "uschar" instead. */
|
||||
|
||||
typedef unsigned char uschar;
|
||||
|
||||
typedef uschar bitset[32];
|
||||
|
||||
/* The real format of the start of the pcre block; the actual code vector
|
||||
runs on as long as necessary after the end. */
|
||||
|
||||
struct pcre
|
||||
{
|
||||
unsigned long int magic_number;
|
||||
size_t size;
|
||||
ssize_t max_match_size;
|
||||
const unsigned char *tables;
|
||||
unsigned long int options;
|
||||
unsigned short int top_bracket;
|
||||
unsigned short int top_backref;
|
||||
uschar first_char;
|
||||
uschar req_char;
|
||||
uschar code[1];
|
||||
};
|
||||
|
||||
/* The real format of the extra block returned by pcre_study(). */
|
||||
|
||||
struct pcre_extra
|
||||
{
|
||||
uschar options;
|
||||
union {
|
||||
bitset start_bits;
|
||||
uschar bmtable[257];
|
||||
} data;
|
||||
};
|
||||
|
||||
|
||||
/* Structure for passing "static" information around between the functions
|
||||
doing the compiling, so that they are thread-safe. */
|
||||
|
||||
typedef struct compile_data
|
||||
{
|
||||
const uschar *lcc; /* Points to lower casing table */
|
||||
const uschar *fcc; /* Points to case-flipping table */
|
||||
const uschar *cbits; /* Points to character type table */
|
||||
const uschar *ctypes; /* Points to table of type maps */
|
||||
const uschar *end; /* Points to last valid byte */
|
||||
ssize_t max_match_size;
|
||||
}
|
||||
compile_data;
|
||||
|
||||
/* Structure for passing "static" information around between the functions
|
||||
doing the matching, so that they are thread-safe. */
|
||||
|
||||
typedef struct match_data
|
||||
{
|
||||
int errorcode; /* As it says */
|
||||
int *offset_vector; /* Offset vector */
|
||||
int offset_end; /* One past the end */
|
||||
int offset_max; /* The maximum usable for return data */
|
||||
const uschar *lcc; /* Points to lower casing table */
|
||||
const uschar *ctypes; /* Points to table of type maps */
|
||||
BOOL offset_overflow; /* Set if too many extractions */
|
||||
BOOL notbol; /* NOTBOL flag */
|
||||
BOOL noteol; /* NOTEOL flag */
|
||||
BOOL utf8; /* UTF8 flag */
|
||||
BOOL endonly; /* Dollar not before final \n */
|
||||
BOOL notempty; /* Empty string match not wanted */
|
||||
const uschar *start_pattern; /* For use when recursing */
|
||||
const uschar *start_subject; /* Start of the subject string */
|
||||
const uschar *end_subject; /* End of the subject string */
|
||||
const uschar *first_start; /* Part of subject considered by preg_exec */
|
||||
const uschar *start_match; /* Start of this match attempt */
|
||||
const uschar *end_match_ptr; /* Subject position at end match */
|
||||
int end_offset_top; /* Highwater mark at end of match */
|
||||
}
|
||||
match_data;
|
||||
|
||||
/* Bit definitions for entries in the pcre_ctypes table. */
|
||||
|
||||
#define ctype_newline 0x01
|
||||
#define ctype_digit 0x02 /* must follow the other in the escapes above */
|
||||
#define ctype_space 0x04
|
||||
#define ctype_word 0x08 /* alphameric or '_' */
|
||||
#define ctype_letter 0x10
|
||||
#define ctype_xdigit 0x20
|
||||
#define ctype_meta 0x80 /* regexp meta char or zero (end pattern) */
|
||||
|
||||
/* Offsets for the bitmap tables in pcre_cbits. Each table contains a set
|
||||
of bits for a class map. Some classes are built by combining these tables. */
|
||||
|
||||
#define cbit_xdigit 0 /* [:xdigit:] */
|
||||
#define cbit_digit 32 /* [:digit:] */
|
||||
#define cbit_space 64 /* [:space:] */
|
||||
#define cbit_word 96 /* [:word:] */
|
||||
#define cbit_upper 128 /* [:upper:] */
|
||||
#define cbit_lower 160 /* [:lower:] */
|
||||
#define cbit_graph 192 /* [:graph:] */
|
||||
#define cbit_print 224 /* [:print:] */
|
||||
#define cbit_punct 256 /* [:punct:] */
|
||||
#define cbit_cntrl 288 /* [:cntrl:] */
|
||||
#define cbit_blank 320 /* [:blank:] */
|
||||
#define cbit_length 352 /* Length of the cbits table */
|
||||
|
||||
/* Offsets of the various tables from the base tables pointer, and
|
||||
total length. */
|
||||
|
||||
#define lcc_offset 0
|
||||
#define fcc_offset 256
|
||||
#define cbits_offset 512
|
||||
#define ctypes_offset (cbits_offset + cbit_length)
|
||||
#define tables_length (ctypes_offset + 256)
|
||||
|
||||
#ifdef __STDC__
|
||||
#define __PCRE_PROTO(a) a
|
||||
#else
|
||||
#define __PCRE_PROTO(a) ()
|
||||
#endif
|
||||
|
||||
extern void pcre_debug __PCRE_PROTO ((pcre *));
|
||||
extern const char *pcre_estrings[];
|
||||
extern const char *pcre_OP_names[];
|
||||
|
||||
#endif
|
||||
+119
@@ -0,0 +1,119 @@
|
||||
/*************************************************
|
||||
* Perl-Compatible Regular Expressions *
|
||||
*************************************************/
|
||||
|
||||
/* Copyright (c) 1997-2000 University of Cambridge */
|
||||
|
||||
#ifndef _PCRE_H
|
||||
#define _PCRE_H
|
||||
|
||||
/* Have to include stdlib.h in order to ensure that size_t is defined;
|
||||
it is needed here for malloc. */
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
#ifdef STDC_HEADERS
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
#ifdef BOOTSTRAP
|
||||
#include <malloc.h>
|
||||
#endif
|
||||
|
||||
/* Allow for C++ users */
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
#ifdef __STDC__
|
||||
#define __PCRE_PROTO(a) a
|
||||
#else
|
||||
#define __PCRE_PROTO(a) ()
|
||||
#endif
|
||||
|
||||
/* Options */
|
||||
|
||||
#define PCRE_CASELESS 0x0001
|
||||
#define PCRE_MULTILINE 0x0002
|
||||
#define PCRE_DOTALL 0x0004
|
||||
#define PCRE_EXTENDED 0x0008
|
||||
#define PCRE_ANCHORED 0x0010
|
||||
#define PCRE_DOLLAR_ENDONLY 0x0020
|
||||
#define PCRE_EXTRA 0x0040
|
||||
#define PCRE_NOTBOL 0x0080
|
||||
#define PCRE_NOTEOL 0x0100
|
||||
#define PCRE_UNGREEDY 0x0200
|
||||
#define PCRE_NOTEMPTY 0x0400
|
||||
#define PCRE_ENGLISH_ERRORS 0x0800
|
||||
#define PCRE_STUDY_NO_PRUNE 0x04
|
||||
#define PCRE_STUDY_NO_START 0x08
|
||||
|
||||
/* Exec-time and get-time error codes */
|
||||
|
||||
#define PCRE_ERROR_NOMATCH (-1)
|
||||
#define PCRE_ERROR_NULL (-2)
|
||||
#define PCRE_ERROR_BADOPTION (-3)
|
||||
#define PCRE_ERROR_BADMAGIC (-4)
|
||||
#define PCRE_ERROR_UNKNOWN_NODE (-5)
|
||||
#define PCRE_ERROR_NOMEMORY (-6)
|
||||
#define PCRE_ERROR_NOSUBSTRING (-7)
|
||||
|
||||
/* Request types for pcre_fullinfo() */
|
||||
|
||||
#define PCRE_INFO_OPTIONS 0
|
||||
#define PCRE_INFO_SIZE 1
|
||||
#define PCRE_INFO_CAPTURECOUNT 2
|
||||
#define PCRE_INFO_BACKREFMAX 3
|
||||
#define PCRE_INFO_FIRSTCHAR 4
|
||||
#define PCRE_INFO_FIRSTTABLE 5
|
||||
#define PCRE_INFO_LASTLITERAL 6
|
||||
#define PCRE_INFO_BMTABLE 7
|
||||
|
||||
/* Types */
|
||||
|
||||
struct pcre;
|
||||
struct pcre_extra;
|
||||
typedef struct pcre pcre;
|
||||
typedef struct pcre_extra pcre_extra;
|
||||
|
||||
/* Store get and free functions. These can be set to alternative malloc/free
|
||||
functions if required. */
|
||||
|
||||
extern void *(*pcre_malloc) (size_t);
|
||||
extern void (*pcre_free) (void *);
|
||||
|
||||
/* Functions */
|
||||
|
||||
extern pcre *pcre_posix_compile __PCRE_PROTO ((const char *, int, const char **,
|
||||
int *, const unsigned char *));
|
||||
extern pcre *pcre_compile __PCRE_PROTO ((const char *, int, const char **,
|
||||
int *, const unsigned char *));
|
||||
extern pcre *pcre_posix_compile_nuls __PCRE_PROTO ((const char *, int, int,
|
||||
const char **, int *,
|
||||
const unsigned char *));
|
||||
extern pcre *pcre_compile_nuls __PCRE_PROTO ((const char *, int, int,
|
||||
const char **, int *,
|
||||
const unsigned char *));
|
||||
extern int pcre_copy_substring __PCRE_PROTO ((const char *, int *, int, int,
|
||||
char *, int));
|
||||
extern int pcre_exec __PCRE_PROTO ((const pcre *, const pcre_extra *,
|
||||
const char *, int, int, int, int *, int));
|
||||
extern void pcre_free_substring __PCRE_PROTO ((const char *));
|
||||
extern void pcre_free_substring_list __PCRE_PROTO ((const char **));
|
||||
extern int pcre_get_substring __PCRE_PROTO ((const char *, int *, int, int,
|
||||
const char **));
|
||||
extern int pcre_get_substring_list __PCRE_PROTO ((const char *, int *, int,
|
||||
const char ***));
|
||||
extern int pcre_info __PCRE_PROTO ((const pcre *, const pcre_extra *, int,
|
||||
void *));
|
||||
extern const unsigned char *pcre_maketables __PCRE_PROTO ((void));
|
||||
extern pcre_extra *pcre_study __PCRE_PROTO ((const pcre *, int, const char **));
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
#undef __PCRE_PROTO
|
||||
|
||||
#endif
|
||||
+282
@@ -0,0 +1,282 @@
|
||||
/*************************************************
|
||||
* pcregrep program *
|
||||
*************************************************/
|
||||
|
||||
/* This is a grep program that uses the PCRE regular expression library to do
|
||||
its pattern matching. */
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
#ifdef STDC_HEADERS
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
#include <errno.h>
|
||||
#include "pcre.h"
|
||||
|
||||
#ifdef HAVE_LOCALE_H
|
||||
#include <locale.h>
|
||||
#endif
|
||||
|
||||
#ifdef ENABLE_NLS
|
||||
# include <libintl.h>
|
||||
#else
|
||||
# define gettext(s) (s)
|
||||
#endif
|
||||
#define _(s) gettext(s)
|
||||
|
||||
#define FALSE 0
|
||||
#define TRUE 1
|
||||
|
||||
typedef int BOOL;
|
||||
|
||||
|
||||
|
||||
/*************************************************
|
||||
* Global variables *
|
||||
*************************************************/
|
||||
|
||||
static pcre *pattern;
|
||||
static pcre_extra *hints;
|
||||
|
||||
static BOOL count_only = FALSE;
|
||||
static BOOL filenames_only = FALSE;
|
||||
static BOOL invert = FALSE;
|
||||
static BOOL number = FALSE;
|
||||
static BOOL silent = FALSE;
|
||||
static BOOL whole_lines = FALSE;
|
||||
|
||||
|
||||
|
||||
|
||||
/*************************************************
|
||||
* Grep an individual file *
|
||||
*************************************************/
|
||||
|
||||
static int
|
||||
pcregrep (in, name)
|
||||
FILE *in;
|
||||
char *name;
|
||||
{
|
||||
int rc = 1;
|
||||
int linenumber = 0;
|
||||
int count = 0;
|
||||
int offsets[99];
|
||||
char buffer[BUFSIZ];
|
||||
|
||||
while (fgets (buffer, sizeof (buffer), in) != NULL)
|
||||
{
|
||||
BOOL match;
|
||||
int length = (int) strlen (buffer);
|
||||
if (length > 0 && buffer[length - 1] == '\n')
|
||||
buffer[--length] = 0;
|
||||
linenumber++;
|
||||
|
||||
match = pcre_exec (pattern, hints, buffer, length, 0, 0, offsets, 99) >= 0;
|
||||
if (match && whole_lines && offsets[1] != length)
|
||||
match = FALSE;
|
||||
|
||||
if (match != invert)
|
||||
{
|
||||
if (count_only)
|
||||
count++;
|
||||
|
||||
else if (filenames_only)
|
||||
{
|
||||
printf("%s\n", (name == NULL) ? "<stdin>" : name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
else if (silent)
|
||||
return 0;
|
||||
|
||||
else
|
||||
{
|
||||
if (name != NULL)
|
||||
printf("%s:", name);
|
||||
if (number)
|
||||
printf("%d:", linenumber);
|
||||
printf("%s\n", buffer);
|
||||
}
|
||||
|
||||
rc = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (count_only)
|
||||
{
|
||||
if (name != NULL)
|
||||
printf("%s:", name);
|
||||
printf("%d\n", count);
|
||||
}
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/*************************************************
|
||||
* Usage function *
|
||||
*************************************************/
|
||||
|
||||
static int
|
||||
usage (rc)
|
||||
int rc;
|
||||
{
|
||||
fprintf (stderr, _("Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"));
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/*************************************************
|
||||
* Main program *
|
||||
*************************************************/
|
||||
|
||||
int
|
||||
main (argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
int i;
|
||||
int rc = 1;
|
||||
int options = 0;
|
||||
int errptr;
|
||||
char kind;
|
||||
const char *error;
|
||||
BOOL filenames = TRUE;
|
||||
|
||||
#if HAVE_SETLOCALE
|
||||
/* Set locale according to user's wishes. */
|
||||
setlocale (LC_ALL, "");
|
||||
#endif
|
||||
|
||||
#if ENABLE_NLS
|
||||
/* Tell program which translations to use and where to find. */
|
||||
/* bindtextdomain (PACKAGE, LOCALEDIR); */
|
||||
textdomain (PACKAGE);
|
||||
#endif
|
||||
|
||||
/* Process the options */
|
||||
kind = 'p';
|
||||
for (i = 1; i < argc; i++)
|
||||
{
|
||||
char *s;
|
||||
if (argv[i][0] != '-')
|
||||
break;
|
||||
s = argv[i] + 1;
|
||||
while (*s != 0)
|
||||
{
|
||||
switch (*s++)
|
||||
{
|
||||
case 'c':
|
||||
count_only = TRUE;
|
||||
break;
|
||||
case 'b':
|
||||
kind = 'b';
|
||||
break;
|
||||
case 'e':
|
||||
kind = 'e';
|
||||
break;
|
||||
case 'p':
|
||||
kind = 'p';
|
||||
break;
|
||||
case 'h':
|
||||
filenames = FALSE;
|
||||
break;
|
||||
case 'i':
|
||||
options |= PCRE_CASELESS;
|
||||
break;
|
||||
case 'l':
|
||||
filenames_only = TRUE;
|
||||
case 'n':
|
||||
number = TRUE;
|
||||
break;
|
||||
case 's':
|
||||
silent = TRUE;
|
||||
break;
|
||||
case 'v':
|
||||
invert = TRUE;
|
||||
break;
|
||||
case 'x':
|
||||
whole_lines = TRUE;
|
||||
options |= PCRE_ANCHORED;
|
||||
break;
|
||||
|
||||
default:
|
||||
fprintf (stderr, _("pcregrep: unknown option %c\n"), s[-1]);
|
||||
return usage (2);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* There must be at least a regexp argument */
|
||||
if (i >= argc)
|
||||
return usage (0);
|
||||
|
||||
/* Compile the regular expression. */
|
||||
switch (kind)
|
||||
{
|
||||
case 'b':
|
||||
pattern = pcre_posix_compile (argv[i++], options, &error, &errptr, NULL);
|
||||
break;
|
||||
case 'e':
|
||||
pattern = pcre_posix_compile (argv[i++], options | PCRE_EXTENDED,
|
||||
&error, &errptr, NULL);
|
||||
break;
|
||||
case 'p':
|
||||
pattern = pcre_compile (argv[i++], options, &error, &errptr, NULL);
|
||||
break;
|
||||
}
|
||||
|
||||
if (pattern == NULL)
|
||||
{
|
||||
fprintf (stderr, _("pcregrep: error in regex at offset %d: %s\n"),
|
||||
errptr, error);
|
||||
return 2;
|
||||
}
|
||||
|
||||
/* Study the regular expression, as we will be running it may times */
|
||||
hints = pcre_study (pattern, 0, &error);
|
||||
if (error != NULL)
|
||||
{
|
||||
fprintf (stderr, _("pcregrep: error while studing regex: %s\n"), error);
|
||||
return 2;
|
||||
}
|
||||
|
||||
/* If there are no further arguments, do the business on stdin and exit */
|
||||
if (i >= argc)
|
||||
return pcregrep (stdin, NULL);
|
||||
|
||||
/* Otherwise, work through the remaining arguments as files. If there is only
|
||||
one, don't give its name on the output. */
|
||||
if (i == argc - 1)
|
||||
filenames = FALSE;
|
||||
if (filenames_only)
|
||||
filenames = TRUE;
|
||||
|
||||
for (; i < argc; i++)
|
||||
{
|
||||
FILE *in = fopen (argv[i], "r");
|
||||
if (in == NULL)
|
||||
{
|
||||
fprintf (stderr, _("pcregrep: failed to open %s: %s\n"),
|
||||
argv[i], strerror (errno));
|
||||
rc = 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
int frc = pcregrep (in, filenames ? argv[i] : NULL);
|
||||
if (frc == 0 && rc == 1)
|
||||
rc = 0;
|
||||
fclose (in);
|
||||
}
|
||||
}
|
||||
|
||||
return rc;
|
||||
}
|
||||
+1040
File diff suppressed because it is too large.
Load diff
+405
@@ -0,0 +1,405 @@
|
||||
/*************************************************
|
||||
* Perl-Compatible Regular Expressions *
|
||||
*************************************************/
|
||||
|
||||
/*
|
||||
This is a library of functions to support regular expressions whose syntax
|
||||
and semantics are as close as possible to those of the Perl 5 language. See
|
||||
the file Tech.Notes for some information on the internals.
|
||||
|
||||
Written by: Philip Hazel <ph10@cam.ac.uk>
|
||||
|
||||
Copyright (c) 1997-2000 University of Cambridge
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
Permission is granted to anyone to use this software for any purpose on any
|
||||
computer system, and to redistribute it freely, subject to the following
|
||||
restrictions:
|
||||
|
||||
1. This software is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
|
||||
2. The origin of this software must not be misrepresented, either by
|
||||
explicit claim or by omission.
|
||||
|
||||
3. Altered versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
|
||||
4. If PCRE is embedded in any software that is released under the GNU
|
||||
General Purpose Licence (GPL), then the terms of that licence shall
|
||||
supersede any condition above with which it is incompatible.
|
||||
-----------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include "internal.h"
|
||||
|
||||
const char *pcre_OP_names[] =
|
||||
{
|
||||
"End", "\\<", "\\>", "\\G", "\\A", "\\B", "\\b",
|
||||
"\\Z", "\\z",
|
||||
"Opt", "^", "$", "Any",
|
||||
"chars", "*", "*?", " once *", "+", "+?", " once +", "?", "??", " once ?", "{", "{", " once {", "{",
|
||||
"not", "*", "*?", " once *", "+", "+?", " once +", "?", "??", " once ?", "{", "{", " once {", "{",
|
||||
"", "*", "*?", " once *", "+", "+?", " once +", "?", "??", " once ?", "{", "{", " once {", "{",
|
||||
"", "*", "*?", " once *", "+", "+?", " once +", "?", "??", " once ?", "{", "{", " once {", "{",
|
||||
"", "*", "*?", " once *", "+", "+?", " once +", "?", "??", " once ?", "{", "{", " once {",
|
||||
"", "*", "*?", " once *", "+", "+?", " once +", "?", "??", " once ?", "{", "{", " once {",
|
||||
"Recurse",
|
||||
"Alt", "Ket", "Ket*", "Ket*?", "Ket once *", "Assert", "Assert not",
|
||||
"AssertB", "AssertB not", "Reverse", "Once", "Cond", "Cref",
|
||||
"Brazero", "Braminzero", "Branumber", "Bra"
|
||||
};
|
||||
|
||||
static const char *TYPE_names[] =
|
||||
{
|
||||
"invalid", "\\d", "\\s", "\\w"
|
||||
};
|
||||
|
||||
static const char *TYPENOT_names[] =
|
||||
{
|
||||
"Any", "\\D", "\\S", "\\W"
|
||||
};
|
||||
|
||||
|
||||
/*************************************************
|
||||
* Debugging function to print regexp *
|
||||
*************************************************/
|
||||
|
||||
void
|
||||
pcre_debug (re)
|
||||
pcre *re;
|
||||
{
|
||||
uschar *code, *code_base;
|
||||
int c;
|
||||
|
||||
printf ("Computed size = %d top_bracket = %d top_backref = %d\n",
|
||||
re->size, re->top_bracket, re->top_backref);
|
||||
|
||||
if (re->max_match_size >= 0)
|
||||
printf ("Can match up to %d characters\n",
|
||||
re->max_match_size);
|
||||
|
||||
|
||||
if (re->options != 0)
|
||||
{
|
||||
printf ("%s%s%s%s%s%s%s%s\n",
|
||||
((re->options & PCRE_ANCHORED) != 0) ? "anchored " : "",
|
||||
((re->options & PCRE_CASELESS) != 0) ? "caseless " : "",
|
||||
((re->options & PCRE_ICHANGED) != 0) ? "case state changed " : "",
|
||||
((re->options & PCRE_MULTILINE) != 0) ? "multiline " : "",
|
||||
((re->options & PCRE_DOTALL) != 0) ? "dotall " : "",
|
||||
((re->options & PCRE_DOLLAR_ENDONLY) != 0) ? "endonly " : "",
|
||||
((re->options & PCRE_EXTRA) != 0) ? "extra " : "",
|
||||
((re->options & PCRE_UNGREEDY) != 0) ? "ungreedy" : "");
|
||||
}
|
||||
|
||||
if ((re->options & PCRE_FIRSTSET) != 0)
|
||||
{
|
||||
if (isascii (re->first_char) && isprint (re->first_char))
|
||||
printf ("First char = %c\n", re->first_char);
|
||||
else
|
||||
printf ("First char = \\x%02x\n", re->first_char);
|
||||
}
|
||||
|
||||
if ((re->options & PCRE_REQCHSET) != 0)
|
||||
{
|
||||
if (isascii (re->req_char) && isprint (re->req_char))
|
||||
printf ("Req char = %c\n", re->req_char);
|
||||
else
|
||||
printf ("Req char = \\x%02x\n", re->req_char);
|
||||
}
|
||||
|
||||
code_base = code = re->code;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
int charlength;
|
||||
|
||||
printf ("%3d ", code - code_base);
|
||||
|
||||
if (*code >= OP_BRA)
|
||||
{
|
||||
if (*code - OP_BRA > EXTRACT_BASIC_MAX)
|
||||
printf("%3d Bra extra", (code[1] << 8) + code[2]);
|
||||
else
|
||||
printf("%3d Bra %d", (code[1] << 8) + code[2], *code - OP_BRA);
|
||||
|
||||
code += 2;
|
||||
}
|
||||
|
||||
else
|
||||
switch (*code)
|
||||
{
|
||||
case OP_OPT:
|
||||
printf (" %.2x %s", code[1], pcre_OP_names[*code]);
|
||||
code++;
|
||||
break;
|
||||
|
||||
case OP_CHARS:
|
||||
charlength = *(++code);
|
||||
printf ("%3d ", charlength);
|
||||
while (charlength-- > 0)
|
||||
{
|
||||
c = *(++code);
|
||||
if (isascii (c) && isprint (c))
|
||||
printf ("%c", c);
|
||||
else
|
||||
printf ("\\x%02x", c);
|
||||
}
|
||||
break;
|
||||
|
||||
case OP_KET_MAXSTAR:
|
||||
case OP_KET_MINSTAR:
|
||||
case OP_KET_ONCESTAR:
|
||||
case OP_ALT:
|
||||
case OP_KET:
|
||||
case OP_ASSERT:
|
||||
case OP_ASSERT_NOT:
|
||||
case OP_ASSERTBACK:
|
||||
case OP_ASSERTBACK_NOT:
|
||||
case OP_ONCE:
|
||||
case OP_REVERSE:
|
||||
case OP_BRANUMBER:
|
||||
case OP_COND:
|
||||
case OP_CREF:
|
||||
printf ("%3d %s", (code[1] << 8) + code[2], pcre_OP_names[*code]);
|
||||
code += 2;
|
||||
break;
|
||||
|
||||
case OP_MAXSTAR:
|
||||
case OP_MINSTAR:
|
||||
case OP_ONCESTAR:
|
||||
case OP_MAXPLUS:
|
||||
case OP_MINPLUS:
|
||||
case OP_ONCEPLUS:
|
||||
case OP_MAXQUERY:
|
||||
case OP_MINQUERY:
|
||||
case OP_ONCEQUERY:
|
||||
c = code[1];
|
||||
if (isascii (c) && isprint (c))
|
||||
printf (" %c", c);
|
||||
else
|
||||
printf (" \\x%02x", c);
|
||||
printf ("%s", pcre_OP_names[*code++]);
|
||||
break;
|
||||
|
||||
case OP_TYPE:
|
||||
case OP_TYPE_MAXSTAR:
|
||||
case OP_TYPE_MINSTAR:
|
||||
case OP_TYPE_ONCESTAR:
|
||||
case OP_TYPE_MAXPLUS:
|
||||
case OP_TYPE_MINPLUS:
|
||||
case OP_TYPE_ONCEPLUS:
|
||||
case OP_TYPE_MAXQUERY:
|
||||
case OP_TYPE_MINQUERY:
|
||||
case OP_TYPE_ONCEQUERY:
|
||||
case OP_TYPENOT:
|
||||
case OP_TYPENOT_MAXSTAR:
|
||||
case OP_TYPENOT_MINSTAR:
|
||||
case OP_TYPENOT_ONCESTAR:
|
||||
case OP_TYPENOT_MAXPLUS:
|
||||
case OP_TYPENOT_MINPLUS:
|
||||
case OP_TYPENOT_ONCEPLUS:
|
||||
case OP_TYPENOT_MAXQUERY:
|
||||
case OP_TYPENOT_MINQUERY:
|
||||
case OP_TYPENOT_ONCEQUERY:
|
||||
c = code[1];
|
||||
if (*code >= OP_TYPENOT)
|
||||
printf (" %s", TYPENOT_names[c]);
|
||||
else
|
||||
printf (" %s", TYPE_names[c]);
|
||||
printf ("%s", pcre_OP_names[*code]);
|
||||
code++;
|
||||
break;
|
||||
|
||||
case OP_EXACT:
|
||||
case OP_MAXUPTO:
|
||||
case OP_MINUPTO:
|
||||
case OP_ONCEUPTO:
|
||||
c = code[3];
|
||||
if (isascii (c) && isprint (c))
|
||||
printf (" %c%s", c, pcre_OP_names[*code]);
|
||||
else
|
||||
printf (" \\x%02x%s", c, pcre_OP_names[*code]);
|
||||
if (*code != OP_EXACT)
|
||||
printf ("0,");
|
||||
printf ("%d}", (code[1] << 8) + code[2]);
|
||||
if (*code == OP_MINUPTO)
|
||||
printf ("?");
|
||||
code += 3;
|
||||
break;
|
||||
|
||||
case OP_TYPEEXACT:
|
||||
case OP_TYPE_MAXUPTO:
|
||||
case OP_TYPE_MINUPTO:
|
||||
case OP_TYPE_ONCEUPTO:
|
||||
printf (" %s%s", TYPE_names[code[3]], pcre_OP_names[*code]);
|
||||
if (*code != OP_TYPEEXACT)
|
||||
printf (",");
|
||||
printf ("%d}", (code[1] << 8) + code[2]);
|
||||
if (*code == OP_TYPE_MINUPTO)
|
||||
printf ("?");
|
||||
code += 3;
|
||||
break;
|
||||
|
||||
case OP_TYPENOTEXACT:
|
||||
case OP_TYPENOT_MAXUPTO:
|
||||
case OP_TYPENOT_MINUPTO:
|
||||
case OP_TYPENOT_ONCEUPTO:
|
||||
printf (" %s%s", TYPENOT_names[code[3]], pcre_OP_names[*code]);
|
||||
if (*code != OP_TYPENOTEXACT)
|
||||
printf (",");
|
||||
printf ("%d}", (code[1] << 8) + code[2]);
|
||||
if (*code == OP_TYPENOT_MINUPTO)
|
||||
printf ("?");
|
||||
code += 3;
|
||||
break;
|
||||
|
||||
case OP_NOT:
|
||||
c = *(++code);
|
||||
|
||||
if (isascii (c) && isprint (c))
|
||||
printf (" [^%c]", c);
|
||||
else
|
||||
printf (" [^\\x%02x]", c);
|
||||
break;
|
||||
|
||||
case OP_NOT_MAXSTAR:
|
||||
case OP_NOT_MINSTAR:
|
||||
case OP_NOT_ONCESTAR:
|
||||
case OP_NOT_MAXPLUS:
|
||||
case OP_NOT_MINPLUS:
|
||||
case OP_NOT_ONCEPLUS:
|
||||
case OP_NOT_MAXQUERY:
|
||||
case OP_NOT_MINQUERY:
|
||||
case OP_NOT_ONCEQUERY:
|
||||
c = code[1];
|
||||
if (isascii (c) && isprint (c))
|
||||
printf (" [^%c]", c);
|
||||
else
|
||||
printf (" [^\\x%02x]", c);
|
||||
printf ("%s", pcre_OP_names[*code++]);
|
||||
break;
|
||||
|
||||
case OP_NOTEXACT:
|
||||
case OP_NOT_MAXUPTO:
|
||||
case OP_NOT_MINUPTO:
|
||||
case OP_NOT_ONCEUPTO:
|
||||
c = code[3];
|
||||
if (isascii (c) && isprint (c))
|
||||
printf (" [^%c]%s", c, pcre_OP_names[*code]);
|
||||
else
|
||||
printf (" [^\\x%02x]%s", c, pcre_OP_names[*code]);
|
||||
if (*code != OP_NOTEXACT)
|
||||
printf (",");
|
||||
printf ("%d}", (code[1] << 8) + code[2]);
|
||||
if (*code == OP_NOT_MINUPTO)
|
||||
printf ("?");
|
||||
code += 3;
|
||||
break;
|
||||
|
||||
case OP_REF:
|
||||
case OP_REF_MAXSTAR:
|
||||
case OP_REF_MINSTAR:
|
||||
case OP_REF_ONCESTAR:
|
||||
case OP_REF_MAXPLUS:
|
||||
case OP_REF_MINPLUS:
|
||||
case OP_REF_ONCEPLUS:
|
||||
case OP_REF_MAXQUERY:
|
||||
case OP_REF_MINQUERY:
|
||||
case OP_REF_ONCEQUERY:
|
||||
case OP_REF_MAXRANGE:
|
||||
case OP_REF_MINRANGE:
|
||||
case OP_REF_ONCERANGE:
|
||||
c = *code - OP_REF + OP_CLASS;
|
||||
printf (" \\%d", code[1] * 256 + code[2]);
|
||||
code += 2;
|
||||
goto CLASS_REF_REPEAT;
|
||||
|
||||
case OP_CLASS:
|
||||
case OP_CL_MAXSTAR:
|
||||
case OP_CL_MINSTAR:
|
||||
case OP_CL_ONCESTAR:
|
||||
case OP_CL_MAXPLUS:
|
||||
case OP_CL_MINPLUS:
|
||||
case OP_CL_ONCEPLUS:
|
||||
case OP_CL_MAXQUERY:
|
||||
case OP_CL_MINQUERY:
|
||||
case OP_CL_ONCEQUERY:
|
||||
case OP_CL_MAXRANGE:
|
||||
case OP_CL_MINRANGE:
|
||||
case OP_CL_ONCERANGE:
|
||||
{
|
||||
int i, min, max;
|
||||
c = *code++;
|
||||
printf (" [");
|
||||
|
||||
for (i = 0; i < 256; i++)
|
||||
{
|
||||
if ((code[i / 8] & (1 << (i & 7))) != 0)
|
||||
{
|
||||
int j;
|
||||
for (j = i + 1; j < 256; j++)
|
||||
if ((code[j / 8] & (1 << (j & 7))) == 0)
|
||||
break;
|
||||
if (i == '-' || i == ']')
|
||||
printf ("\\");
|
||||
if (isascii (i) && isprint (i))
|
||||
printf ("%c", i);
|
||||
else
|
||||
printf ("\\x%02x", i);
|
||||
if (--j > i)
|
||||
{
|
||||
printf ("-");
|
||||
if (j == '-' || j == ']')
|
||||
printf ("\\");
|
||||
if (isascii (j) && isprint (j))
|
||||
printf ("%c", j);
|
||||
else
|
||||
printf ("\\x%02x", j);
|
||||
}
|
||||
i = j;
|
||||
}
|
||||
}
|
||||
printf ("]");
|
||||
code += 31;
|
||||
|
||||
CLASS_REF_REPEAT:
|
||||
|
||||
printf ("%s", pcre_OP_names[c]);
|
||||
|
||||
if (c == OP_CL_MAXRANGE || c == OP_CL_MINRANGE || c == OP_CL_ONCERANGE ||
|
||||
c == OP_REF_MAXRANGE || c == OP_REF_MINRANGE || c == OP_REF_ONCERANGE)
|
||||
{
|
||||
min = (code[1] << 8) + code[2];
|
||||
max = (code[3] << 8) + code[4];
|
||||
if (max == 0)
|
||||
printf ("%d,}", min);
|
||||
else
|
||||
printf ("%d,%d}", min, max);
|
||||
if (c == OP_CL_MINRANGE || c == OP_REF_MINRANGE)
|
||||
printf ("?");
|
||||
code += 4;
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case OP_END:
|
||||
printf (" %s\n", pcre_OP_names[*code]);
|
||||
printf ("------------------------------------------------------------------\n");
|
||||
return;
|
||||
|
||||
/* Anything else is just a one-node item */
|
||||
|
||||
default:
|
||||
printf (" %s", pcre_OP_names[*code]);
|
||||
break;
|
||||
}
|
||||
|
||||
code++;
|
||||
printf ("\n");
|
||||
}
|
||||
}
|
||||
|
||||
+2095
File diff suppressed because it is too large.
Load diff
+381
@@ -0,0 +1,381 @@
|
||||
/*************************************************
|
||||
* Perl-Compatible Regular Expressions *
|
||||
*************************************************/
|
||||
|
||||
/*
|
||||
This is a library of functions to support regular expressions whose syntax
|
||||
and semantics are as close as possible to those of the Perl 5 language. See
|
||||
the file Tech.Notes for some information on the internals.
|
||||
|
||||
This module is a wrapper that provides a POSIX API to the underlying PCRE
|
||||
functions.
|
||||
|
||||
Written by: Philip Hazel <ph10@cam.ac.uk>
|
||||
|
||||
Copyright (c) 1997-2000 University of Cambridge
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
Permission is granted to anyone to use this software for any purpose on any
|
||||
computer system, and to redistribute it freely, subject to the following
|
||||
restrictions:
|
||||
|
||||
1. This software is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
|
||||
2. The origin of this software must not be misrepresented, either by
|
||||
explicit claim or by omission.
|
||||
|
||||
3. Altered versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
|
||||
4. If PCRE is embedded in any software that is released under the GNU
|
||||
General Purpose Licence (GPL), then the terms of that licence shall
|
||||
supersede any condition above with which it is incompatible.
|
||||
-----------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include "internal.h"
|
||||
#include "regexp.h"
|
||||
#include "stdlib.h"
|
||||
|
||||
|
||||
/* Corresponding tables of PCRE error messages and POSIX error codes. */
|
||||
|
||||
const char *pcre_estrings[] =
|
||||
{
|
||||
"",
|
||||
N_("\\ at end of pattern"),
|
||||
N_("\\c at end of pattern"),
|
||||
N_("unrecognized character follows \\"),
|
||||
N_("numbers out of order in {} quantifier"),
|
||||
N_("number too big in {} quantifier"),
|
||||
N_("missing terminating ] for character class"),
|
||||
N_("invalid escape sequence in character class"),
|
||||
N_("range out of order in character class"),
|
||||
N_("nothing to repeat"),
|
||||
N_("operand of unlimited repeat could match the empty string"),
|
||||
N_("internal error: unexpected repeat"),
|
||||
N_("unrecognized character after (?"),
|
||||
N_("unused error"),
|
||||
N_("unmatched braces"),
|
||||
N_("back reference to non-existent subpattern"),
|
||||
N_("erroffset passed as NULL"),
|
||||
N_("unknown option bit(s) set"),
|
||||
N_("missing ) after comment"),
|
||||
N_("parentheses nested too deeply"),
|
||||
N_("regular expression too large"),
|
||||
N_("failed to get memory"),
|
||||
N_("unmatched parentheses"),
|
||||
N_("internal error: code overflow"),
|
||||
N_("unrecognized character after (?<"),
|
||||
N_("lookbehind assertion is not fixed length"),
|
||||
N_("malformed number after (?("),
|
||||
N_("conditional group contains more than two branches"),
|
||||
N_("assertion expected after (?("),
|
||||
N_("(?p must be followed by )"),
|
||||
N_("unknown POSIX class name"),
|
||||
N_("POSIX collating elements are not supported"),
|
||||
N_("bad condition (?(0)")
|
||||
};
|
||||
|
||||
static int eint[] =
|
||||
{
|
||||
0,
|
||||
REG_EESCAPE, /* \\ at end of pattern */
|
||||
REG_EESCAPE, /* \\c at end of pattern */
|
||||
REG_EESCAPE, /* unrecognized character follows \\ */
|
||||
REG_BADBR, /* numbers out of order in {} quantifier */
|
||||
REG_BADBR, /* number too big in {} quantifier */
|
||||
REG_EBRACK, /* missing terminating ] for character class */
|
||||
REG_ECTYPE, /* invalid escape sequence in character class */
|
||||
REG_ERANGE, /* range out of order in character class */
|
||||
REG_BADRPT, /* nothing to repeat */
|
||||
REG_BADRPT, /* operand of unlimited repeat could match the empty string */
|
||||
REG_ASSERT, /* internal error: unexpected repeat */
|
||||
REG_BADPAT, /* unrecognized character after (? */
|
||||
REG_ASSERT, /* unused error */
|
||||
REG_EPAREN, /* missing ) */
|
||||
REG_ESUBREG, /* back reference to non-existent subpattern */
|
||||
REG_INVARG, /* erroffset passed as NULL */
|
||||
REG_INVARG, /* unknown option bit(s) set */
|
||||
REG_EPAREN, /* missing ) after comment */
|
||||
REG_ESIZE, /* parentheses nested too deeply */
|
||||
REG_ESIZE, /* regular expression too large */
|
||||
REG_ESPACE, /* failed to get memory */
|
||||
REG_EPAREN, /* unmatched brackets */
|
||||
REG_ASSERT, /* internal error: code overflow */
|
||||
REG_BADPAT, /* unrecognized character after (?< */
|
||||
REG_BADPAT, /* lookbehind assertion is not fixed length */
|
||||
REG_BADPAT, /* malformed number after (?( */
|
||||
REG_BADPAT, /* conditional group containe more than two branches */
|
||||
REG_BADPAT, /* assertion expected after (?( */
|
||||
REG_BADPAT, /* (?p must be followed by ) */
|
||||
REG_ECTYPE, /* unknown POSIX class name */
|
||||
REG_BADPAT, /* POSIX collating elements are not supported */
|
||||
REG_BADPAT, /* character value in \x{...} sequence is too large */
|
||||
REG_BADPAT /* invalid condition (?(0) */
|
||||
};
|
||||
|
||||
/* Table of texts corresponding to POSIX error codes */
|
||||
|
||||
static const char *pstring[] =
|
||||
{
|
||||
"",
|
||||
N_("internal error"),
|
||||
N_("invalid repeat counts in {}"),
|
||||
N_("pattern error"),
|
||||
N_("nothing to repeat"),
|
||||
N_("unmatched braces"),
|
||||
N_("missing terminating ] for character class"),
|
||||
N_("bad collating element"),
|
||||
N_("unknown POSIX class name"),
|
||||
N_("bad escape sequence"),
|
||||
N_("empty expression"),
|
||||
N_("unmatched parentheses"),
|
||||
N_("range out of order in character class"),
|
||||
N_("regular expression too large"),
|
||||
N_("failed to get memory"),
|
||||
N_("back reference to non-existent subpattern"),
|
||||
N_("bad argument"),
|
||||
N_("match failed")
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
/*************************************************
|
||||
* Translate PCRE text code to int *
|
||||
*************************************************/
|
||||
|
||||
/* PCRE compile-time errors are given as strings defined as macros. We can just
|
||||
look them up in a table to turn them into POSIX-style error codes. */
|
||||
|
||||
static int
|
||||
pcre_posix_error_code (s)
|
||||
const char *s;
|
||||
{
|
||||
size_t i;
|
||||
for (i = 1; i < sizeof (pcre_estrings) / sizeof (char *); i++)
|
||||
if (strcmp (s, pcre_estrings[i]) == 0)
|
||||
return eint[i];
|
||||
return REG_ASSERT;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*************************************************
|
||||
* Translate error code to string *
|
||||
*************************************************/
|
||||
|
||||
size_t
|
||||
regerror (errcode, preg, errbuf, errbuf_size)
|
||||
int errcode;
|
||||
const regex_t *preg;
|
||||
char *errbuf;
|
||||
size_t errbuf_size;
|
||||
{
|
||||
const char *message, *addmessage;
|
||||
size_t size;
|
||||
|
||||
message = (errcode >= (int) (sizeof (pstring) / sizeof (char *))) ?
|
||||
_("unknown error code") : gettext(pstring[errcode]);
|
||||
|
||||
addmessage = _("%s at offset %-6d");
|
||||
|
||||
if (errbuf_size > 0)
|
||||
{
|
||||
if (preg != NULL && (int) preg->re_erroffset != -1)
|
||||
size = snprintf (errbuf, errbuf_size - 1, addmessage,
|
||||
message, (int) preg->re_erroffset);
|
||||
else
|
||||
strncpy (errbuf, message, errbuf_size - 1);
|
||||
}
|
||||
|
||||
errbuf[errbuf_size - 1] = 0;
|
||||
return strlen(errbuf);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/*************************************************
|
||||
* Free store held by a regex *
|
||||
*************************************************/
|
||||
|
||||
void
|
||||
regfree (preg)
|
||||
regex_t *preg;
|
||||
{
|
||||
(pcre_free) (preg->re_pcre);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/*************************************************
|
||||
* Compile a regular expression *
|
||||
*************************************************/
|
||||
|
||||
/*
|
||||
Arguments:
|
||||
preg points to a structure for recording the compiled expression
|
||||
pattern the pattern to compile
|
||||
cflags compilation flags
|
||||
|
||||
Returns: 0 on success
|
||||
various non-zero codes on failure
|
||||
*/
|
||||
|
||||
int
|
||||
regcomp (preg, pattern, cflags)
|
||||
regex_t *preg;
|
||||
const char *pattern;
|
||||
int cflags;
|
||||
{
|
||||
return regncomp (preg, pattern, (int) strlen (pattern), cflags);
|
||||
}
|
||||
|
||||
int
|
||||
regncomp (preg, pattern, length, cflags)
|
||||
regex_t *preg;
|
||||
const char *pattern;
|
||||
int length, cflags;
|
||||
{
|
||||
const char *errptr;
|
||||
int errofs;
|
||||
int options = PCRE_ENGLISH_ERRORS;
|
||||
|
||||
options |= (cflags & REG_ICASE) ? PCRE_CASELESS : 0;
|
||||
options |= (cflags & REG_EXTENDED) ? PCRE_EXTENDED : 0;
|
||||
|
||||
if ((cflags & REG_PERL) != 0)
|
||||
{
|
||||
options |= (cflags & REG_NEWLINE) ? PCRE_MULTILINE : 0;
|
||||
options |= (cflags & REG_DOTALL) ? PCRE_DOTALL : 0;
|
||||
preg->re_pcre = pcre_compile_nuls (pattern, length, options,
|
||||
&errptr, &errofs, NULL);
|
||||
}
|
||||
else
|
||||
{
|
||||
options |= (cflags & REG_NEWLINE) ? PCRE_MULTILINE : PCRE_DOTALL;
|
||||
preg->re_pcre = pcre_posix_compile_nuls (pattern, length, options,
|
||||
&errptr, &errofs, NULL);
|
||||
}
|
||||
|
||||
preg->re_erroffset = errofs;
|
||||
|
||||
if (preg->re_pcre == NULL)
|
||||
return pcre_posix_error_code (errptr);
|
||||
|
||||
preg->re_study = pcre_study (preg->re_pcre, 0, &errptr);
|
||||
|
||||
pcre_info (preg->re_pcre, preg->re_study,
|
||||
PCRE_INFO_CAPTURECOUNT, &preg->re_nsub);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/*************************************************
|
||||
* Match a regular expression *
|
||||
*************************************************/
|
||||
|
||||
int
|
||||
regexec (preg, string, nmatch, pmatch, eflags)
|
||||
regex_t *preg;
|
||||
const char *string;
|
||||
size_t nmatch;
|
||||
regmatch_t pmatch[];
|
||||
int eflags;
|
||||
{
|
||||
|
||||
if (eflags & REG_STARTEND)
|
||||
return regnexec (preg, string, 0, nmatch, pmatch, eflags);
|
||||
else
|
||||
return regnexec (preg, string, (int) strlen (string),
|
||||
nmatch, pmatch, eflags);
|
||||
}
|
||||
|
||||
int
|
||||
regnexec (preg, string, length, nmatch, pmatch, eflags)
|
||||
regex_t *preg;
|
||||
const char *string;
|
||||
int length;
|
||||
size_t nmatch;
|
||||
regmatch_t pmatch[];
|
||||
int eflags;
|
||||
{
|
||||
int start;
|
||||
int rc;
|
||||
int options;
|
||||
int *ovector = NULL;
|
||||
|
||||
if (eflags & REG_STARTEND)
|
||||
{
|
||||
start = pmatch[0].rm_so;
|
||||
length = pmatch[0].rm_eo;
|
||||
}
|
||||
else
|
||||
start = 0;
|
||||
|
||||
options =
|
||||
((eflags & REG_NOTBOL) ? PCRE_NOTBOL : 0) |
|
||||
((eflags & REG_NOTEOL) ? PCRE_NOTEOL : 0);
|
||||
|
||||
preg->re_erroffset = (size_t) (-1); /* Only has meaning after compile */
|
||||
|
||||
/* Unfortunately, PCRE requires 3 ints of working space for each captured
|
||||
substring, so we have to get and release working store instead of just using
|
||||
the POSIX structures as was done in earlier releases when PCRE needed only 2
|
||||
ints. */
|
||||
|
||||
ovector = (int *) (pcre_malloc) (sizeof (int) * (preg->re_nsub * 3 + 3));
|
||||
if (ovector == NULL)
|
||||
return REG_ESPACE;
|
||||
|
||||
rc = pcre_exec (preg->re_pcre, preg->re_study, string, length,
|
||||
start, options, ovector, preg->re_nsub * 3 + 3);
|
||||
|
||||
if (rc > 0)
|
||||
{
|
||||
size_t i, max;
|
||||
max = rc < nmatch ? rc : nmatch;
|
||||
|
||||
for (i = 0; i < max; i++)
|
||||
{
|
||||
pmatch[i].rm_so = ovector[i * 2];
|
||||
pmatch[i].rm_eo = ovector[i * 2 + 1];
|
||||
}
|
||||
for (; i < nmatch; i++)
|
||||
pmatch[i].rm_so = pmatch[i].rm_eo = -1;
|
||||
|
||||
(pcre_free) (ovector);
|
||||
return 0;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
(pcre_free) (ovector);
|
||||
switch (rc)
|
||||
{
|
||||
case PCRE_ERROR_NOMATCH:
|
||||
return REG_NOMATCH;
|
||||
case PCRE_ERROR_NULL:
|
||||
return REG_INVARG;
|
||||
case PCRE_ERROR_BADOPTION:
|
||||
return REG_INVARG;
|
||||
case PCRE_ERROR_BADMAGIC:
|
||||
return REG_INVARG;
|
||||
case PCRE_ERROR_UNKNOWN_NODE:
|
||||
return REG_ASSERT;
|
||||
case PCRE_ERROR_NOMEMORY:
|
||||
return REG_ESPACE;
|
||||
default:
|
||||
return REG_ASSERT;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+107
@@ -0,0 +1,107 @@
|
||||
/*************************************************
|
||||
* Perl-Compatible Regular Expressions *
|
||||
*************************************************/
|
||||
|
||||
/* Copyright (c) 1997-2000 University of Cambridge */
|
||||
|
||||
#ifndef _PCREPOSIX_H
|
||||
#define _PCREPOSIX_H
|
||||
|
||||
/* This is the header for the POSIX wrapper interface to the PCRE Perl-
|
||||
Compatible Regular Expression library. It defines the things POSIX says should
|
||||
be there. I hope. */
|
||||
|
||||
/* Have to include stdlib.h in order to ensure that size_t is defined. */
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
/* Allow for C++ users */
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
#ifdef __STDC__
|
||||
#define __PCRE_PROTO(a) a
|
||||
#else
|
||||
#define __PCRE_PROTO(a) ()
|
||||
#endif
|
||||
|
||||
/* Options defined by POSIX. */
|
||||
|
||||
#define REG_ICASE 0x01
|
||||
#define REG_NEWLINE 0x02
|
||||
#define REG_NOTBOL 0x04
|
||||
#define REG_NOTEOL 0x08
|
||||
#define REG_EXTENDED 0x10
|
||||
|
||||
#define REG_PERL 0x20
|
||||
#define REG_DOTALL 0x40
|
||||
#define REG_STARTEND 0x80
|
||||
|
||||
/* These are not used by PCRE, but by defining them we make it easier
|
||||
to slot PCRE into existing programs that make POSIX calls. */
|
||||
|
||||
#define REG_NOSUB 0
|
||||
|
||||
/* Error values. Not all these are relevant or used by the wrapper. */
|
||||
|
||||
enum {
|
||||
REG_ASSERT = 1, /* internal error ? */
|
||||
REG_BADBR, /* invalid repeat counts in {} */
|
||||
REG_BADPAT, /* pattern error */
|
||||
REG_BADRPT, /* ? * + invalid */
|
||||
REG_EBRACE, /* unbalanced {} */
|
||||
REG_EBRACK, /* unbalanced [] */
|
||||
REG_ECOLLATE, /* collation error - not relevant */
|
||||
REG_ECTYPE, /* bad class */
|
||||
REG_EESCAPE, /* bad escape sequence */
|
||||
REG_EMPTY, /* empty expression */
|
||||
REG_EPAREN, /* unbalanced () */
|
||||
REG_ERANGE, /* bad range inside [] */
|
||||
REG_ESIZE, /* expression too big */
|
||||
REG_ESPACE, /* failed to get memory */
|
||||
REG_ESUBREG, /* bad back reference */
|
||||
REG_INVARG, /* bad argument */
|
||||
REG_NOMATCH /* match failed */
|
||||
};
|
||||
|
||||
|
||||
/* The structure representing a compiled regular expression. */
|
||||
|
||||
typedef struct
|
||||
{
|
||||
void *re_pcre;
|
||||
void *re_study;
|
||||
size_t re_nsub;
|
||||
size_t re_erroffset;
|
||||
} regex_t;
|
||||
|
||||
/* The structure in which a captured offset is returned. */
|
||||
|
||||
typedef int regoff_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
regoff_t rm_so;
|
||||
regoff_t rm_eo;
|
||||
} regmatch_t;
|
||||
|
||||
/* The functions */
|
||||
|
||||
extern int regcomp __PCRE_PROTO ((regex_t *, const char *, int));
|
||||
extern int regncomp __PCRE_PROTO ((regex_t *, const char *, int, int));
|
||||
extern int regexec __PCRE_PROTO ((regex_t *, const char *, size_t,
|
||||
regmatch_t *, int));
|
||||
extern int regnexec __PCRE_PROTO ((regex_t *, const char *, int, size_t,
|
||||
regmatch_t *, int));
|
||||
extern size_t regerror __PCRE_PROTO ((int, const regex_t *, char *, size_t));
|
||||
extern void regfree __PCRE_PROTO ((regex_t *));
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
#undef __PCRE_PROTO
|
||||
|
||||
#endif
|
||||
+111
@@ -0,0 +1,111 @@
|
||||
/*************************************************
|
||||
* Perl-Compatible Regular Expressions *
|
||||
*************************************************/
|
||||
|
||||
/*
|
||||
This is a library of functions to support regular expressions whose syntax
|
||||
and semantics are as close as possible to those of the Perl 5 language. See
|
||||
the file Tech.Notes for some information on the internals.
|
||||
|
||||
Written by: Philip Hazel <ph10@cam.ac.uk>
|
||||
|
||||
Copyright (c) 1997-2000 University of Cambridge
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
Permission is granted to anyone to use this software for any purpose on any
|
||||
computer system, and to redistribute it freely, subject to the following
|
||||
restrictions:
|
||||
|
||||
1. This software is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
|
||||
2. The origin of this software must not be misrepresented, either by
|
||||
explicit claim or by omission.
|
||||
|
||||
3. Altered versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
|
||||
4. If PCRE is embedded in any software that is released under the GNU
|
||||
General Purpose Licence (GPL), then the terms of that licence shall
|
||||
supersede any condition above with which it is incompatible.
|
||||
-----------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include "internal.h"
|
||||
|
||||
/*************************************************
|
||||
* Return info about compiled pattern *
|
||||
*************************************************/
|
||||
|
||||
/* This is a newer "info" function which has an extensible interface so
|
||||
that additional items can be added compatibly.
|
||||
|
||||
Arguments:
|
||||
external_re points to compiled code
|
||||
external_study points to study data, or NULL
|
||||
what what information is required
|
||||
where where to put the information
|
||||
|
||||
Returns: 0 if data returned, negative on error
|
||||
*/
|
||||
|
||||
int
|
||||
pcre_info (re, study, what, where)
|
||||
const pcre *re;
|
||||
const pcre_extra *study;
|
||||
int what;
|
||||
void *where;
|
||||
{
|
||||
if (re == NULL || where == NULL)
|
||||
return PCRE_ERROR_NULL;
|
||||
if (re->magic_number != MAGIC_NUMBER)
|
||||
return PCRE_ERROR_BADMAGIC;
|
||||
|
||||
switch (what)
|
||||
{
|
||||
case PCRE_INFO_OPTIONS:
|
||||
*((unsigned long int *) where) = re->options & PUBLIC_OPTIONS;
|
||||
break;
|
||||
|
||||
case PCRE_INFO_SIZE:
|
||||
*((size_t *) where) = re->size;
|
||||
break;
|
||||
|
||||
case PCRE_INFO_CAPTURECOUNT:
|
||||
*((int *) where) = re->top_bracket;
|
||||
break;
|
||||
|
||||
case PCRE_INFO_BACKREFMAX:
|
||||
*((int *) where) = re->top_backref;
|
||||
break;
|
||||
|
||||
case PCRE_INFO_FIRSTCHAR:
|
||||
*((int *) where) =
|
||||
((re->options & PCRE_FIRSTSET) != 0) ? re->first_char :
|
||||
((re->options & PCRE_STARTLINE) != 0) ? -1 : -2;
|
||||
break;
|
||||
|
||||
case PCRE_INFO_BMTABLE:
|
||||
*((const uschar **) where) =
|
||||
(study != NULL && (study->options & PCRE_STUDY_BM) != 0) ?
|
||||
study->data.bmtable : NULL;
|
||||
break;
|
||||
|
||||
case PCRE_INFO_FIRSTTABLE:
|
||||
*((const uschar **) where) =
|
||||
(study != NULL && (study->options & PCRE_STUDY_MAPPED) != 0) ?
|
||||
study->data.start_bits : NULL;
|
||||
break;
|
||||
|
||||
case PCRE_INFO_LASTLITERAL:
|
||||
*((int *) where) =
|
||||
((re->options & PCRE_REQCHSET) != 0) ? re->req_char : -1;
|
||||
break;
|
||||
|
||||
default:
|
||||
return PCRE_ERROR_BADOPTION;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
+2261
File diff suppressed because it is too large.
Load diff
+1921
File diff suppressed because it is too large.
Load diff
+1352
File diff suppressed because it is too large.
Load diff
+242
@@ -0,0 +1,242 @@
|
||||
/*************************************************
|
||||
* Perl-Compatible Regular Expressions *
|
||||
*************************************************/
|
||||
|
||||
/*
|
||||
This is a library of functions to support regular expressions whose syntax
|
||||
and semantics are as close as possible to those of the Perl 5 language. See
|
||||
the file Tech.Notes for some information on the internals.
|
||||
|
||||
Written by: Philip Hazel <ph10@cam.ac.uk>
|
||||
|
||||
Copyright (c) 1997-2000 University of Cambridge
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
Permission is granted to anyone to use this software for any purpose on any
|
||||
computer system, and to redistribute it freely, subject to the following
|
||||
restrictions:
|
||||
|
||||
1. This software is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
|
||||
2. The origin of this software must not be misrepresented, either by
|
||||
explicit claim or by omission.
|
||||
|
||||
3. Altered versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
|
||||
4. If PCRE is embedded in any software that is released under the GNU
|
||||
General Purpose Licence (GPL), then the terms of that licence shall
|
||||
supersede any condition above with which it is incompatible.
|
||||
-----------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/* This module contains some convenience functions for extracting substrings
|
||||
from the subject string after a regex match has succeeded. The original idea
|
||||
for these functions came from Scott Wimer <scottw@cgibuilder.com>. */
|
||||
|
||||
|
||||
/* Include the internals header, which itself includes Standard C headers plus
|
||||
the external pcre header. */
|
||||
|
||||
#include "internal.h"
|
||||
|
||||
|
||||
|
||||
/*************************************************
|
||||
* Copy captured string to given buffer *
|
||||
*************************************************/
|
||||
|
||||
/* This function copies a single captured substring into a given buffer.
|
||||
Note that we use memcpy() rather than strncpy() in case there are binary zeros
|
||||
in the string.
|
||||
|
||||
Arguments:
|
||||
subject the subject string that was matched
|
||||
ovector pointer to the offsets table
|
||||
stringcount the number of substrings that were captured
|
||||
(i.e. the yield of the pcre_exec call, unless
|
||||
that was zero, in which case it should be 1/3
|
||||
of the offset table size)
|
||||
stringnumber the number of the required substring
|
||||
buffer where to put the substring
|
||||
size the size of the buffer
|
||||
|
||||
Returns: if successful:
|
||||
the length of the copied string, not including the zero
|
||||
that is put on the end; can be zero
|
||||
if not successful:
|
||||
PCRE_ERROR_NOMEMORY (-6) buffer too small
|
||||
PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
|
||||
*/
|
||||
|
||||
int
|
||||
pcre_copy_substring (subject, ovector, stringcount, stringnumber, buffer, size)
|
||||
const char *subject;
|
||||
int *ovector;
|
||||
int stringcount;
|
||||
int stringnumber;
|
||||
char *buffer;
|
||||
int size;
|
||||
{
|
||||
int yield;
|
||||
if (stringnumber < 0 || stringnumber >= stringcount)
|
||||
return PCRE_ERROR_NOSUBSTRING;
|
||||
stringnumber *= 2;
|
||||
yield = ovector[stringnumber + 1] - ovector[stringnumber];
|
||||
if (size < yield + 1)
|
||||
return PCRE_ERROR_NOMEMORY;
|
||||
memcpy (buffer, subject + ovector[stringnumber], yield);
|
||||
buffer[yield] = 0;
|
||||
return yield;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*************************************************
|
||||
* Copy all captured strings to new store *
|
||||
*************************************************/
|
||||
|
||||
/* This function gets one chunk of store and builds a list of pointers and all
|
||||
of the captured substrings in it. A NULL pointer is put on the end of the list.
|
||||
|
||||
Arguments:
|
||||
subject the subject string that was matched
|
||||
ovector pointer to the offsets table
|
||||
stringcount the number of substrings that were captured
|
||||
(i.e. the yield of the pcre_exec call, unless
|
||||
that was zero, in which case it should be 1/3
|
||||
of the offset table size)
|
||||
listptr set to point to the list of pointers
|
||||
|
||||
Returns: if successful: 0
|
||||
if not successful:
|
||||
PCRE_ERROR_NOMEMORY (-6) failed to get store
|
||||
*/
|
||||
|
||||
int
|
||||
pcre_get_substring_list (subject, ovector, stringcount, listptr)
|
||||
const char *subject;
|
||||
int *ovector;
|
||||
int stringcount;
|
||||
const char ***listptr;
|
||||
{
|
||||
int i;
|
||||
int size = sizeof (char *);
|
||||
int double_count = stringcount * 2;
|
||||
char **stringlist;
|
||||
char *p;
|
||||
|
||||
for (i = 0; i < double_count; i += 2)
|
||||
size += sizeof (char *) + ovector[i + 1] - ovector[i] + 1;
|
||||
|
||||
stringlist = (char **) (pcre_malloc) (size);
|
||||
if (stringlist == NULL)
|
||||
return PCRE_ERROR_NOMEMORY;
|
||||
|
||||
*listptr = (const char **) stringlist;
|
||||
p = (char *) (stringlist + stringcount + 1);
|
||||
|
||||
for (i = 0; i < double_count; i += 2)
|
||||
{
|
||||
int len = ovector[i + 1] - ovector[i];
|
||||
memcpy (p, subject + ovector[i], len);
|
||||
*stringlist++ = p;
|
||||
p += len;
|
||||
*p++ = 0;
|
||||
}
|
||||
|
||||
*stringlist = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*************************************************
|
||||
* Free store obtained by get_substring_list *
|
||||
*************************************************/
|
||||
|
||||
/* This function exists for the benefit of people calling PCRE from non-C
|
||||
programs that can call its functions, but not free() or (pcre_free)() directly.
|
||||
|
||||
Argument: the result of a previous pcre_get_substring_list()
|
||||
Returns: nothing
|
||||
*/
|
||||
|
||||
void
|
||||
pcre_free_substring_list (pointer)
|
||||
const char **pointer;
|
||||
{
|
||||
(pcre_free) ((void *) pointer);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*************************************************
|
||||
* Copy captured string to new store *
|
||||
*************************************************/
|
||||
|
||||
/* This function copies a single captured substring into a piece of new
|
||||
store
|
||||
|
||||
Arguments:
|
||||
subject the subject string that was matched
|
||||
ovector pointer to the offsets table
|
||||
stringcount the number of substrings that were captured
|
||||
(i.e. the yield of the pcre_exec call, unless
|
||||
that was zero, in which case it should be 1/3
|
||||
of the offset table size)
|
||||
stringnumber the number of the required substring
|
||||
stringptr where to put a pointer to the substring
|
||||
|
||||
Returns: if successful:
|
||||
the length of the string, not including the zero that
|
||||
is put on the end; can be zero
|
||||
if not successful:
|
||||
PCRE_ERROR_NOMEMORY (-6) failed to get store
|
||||
PCRE_ERROR_NOSUBSTRING (-7) substring not present
|
||||
*/
|
||||
|
||||
int
|
||||
pcre_get_substring (subject, ovector, stringcount, stringnumber, stringptr)
|
||||
const char *subject;
|
||||
int *ovector;
|
||||
int stringcount;
|
||||
int stringnumber;
|
||||
const char **stringptr;
|
||||
{
|
||||
int yield;
|
||||
char *substring;
|
||||
if (stringnumber < 0 || stringnumber >= stringcount)
|
||||
return PCRE_ERROR_NOSUBSTRING;
|
||||
stringnumber *= 2;
|
||||
yield = ovector[stringnumber + 1] - ovector[stringnumber];
|
||||
substring = (char *) (pcre_malloc) (yield + 1);
|
||||
if (substring == NULL)
|
||||
return PCRE_ERROR_NOMEMORY;
|
||||
memcpy (substring, subject + ovector[stringnumber], yield);
|
||||
substring[yield] = 0;
|
||||
*stringptr = substring;
|
||||
return yield;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*************************************************
|
||||
* Free store obtained by get_substring *
|
||||
*************************************************/
|
||||
|
||||
/* This function exists for the benefit of people calling PCRE from non-C
|
||||
programs that can call its functions, but not free() or (pcre_free)() directly.
|
||||
|
||||
Argument: the result of a previous pcre_get_substring()
|
||||
Returns: nothing
|
||||
*/
|
||||
|
||||
void
|
||||
pcre_free_substring (pointer)
|
||||
const char *pointer;
|
||||
{
|
||||
(pcre_free) ((void *) pointer);
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
/*************************************************
|
||||
* Perl-Compatible Regular Expressions *
|
||||
*************************************************/
|
||||
|
||||
/*
|
||||
PCRE is a library of functions to support regular expressions whose syntax
|
||||
and semantics are as close as possible to those of the Perl 5 language.
|
||||
|
||||
Written by: Philip Hazel <ph10@cam.ac.uk>
|
||||
|
||||
Copyright (c) 1997-2000 University of Cambridge
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
Permission is granted to anyone to use this software for any purpose on any
|
||||
computer system, and to redistribute it freely, subject to the following
|
||||
restrictions:
|
||||
|
||||
1. This software is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
|
||||
2. The origin of this software must not be misrepresented, either by
|
||||
explicit claim or by omission.
|
||||
|
||||
3. Altered versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
|
||||
4. If PCRE is embedded in any software that is released under the GNU
|
||||
General Purpose Licence (GPL), then the terms of that licence shall
|
||||
supersede any condition above with which it is incompatible.
|
||||
-----------------------------------------------------------------------------
|
||||
|
||||
See the file Tech.Notes for some information on the internals.
|
||||
*/
|
||||
|
||||
#include "internal.h"
|
||||
|
||||
#if !defined HAVE_ISBLANK && !defined isblank
|
||||
# define isblank(ch) ((ch) == ' ' || (ch) == '\t')
|
||||
#endif
|
||||
|
||||
/*************************************************
|
||||
* Create PCRE character tables *
|
||||
*************************************************/
|
||||
|
||||
/* This function builds a set of character tables for use by PCRE and returns
|
||||
a pointer to them. They are build using the ctype functions, and consequently
|
||||
their contents will depend upon the current locale setting. When compiled as
|
||||
part of the library, the store is obtained via pcre_malloc().
|
||||
|
||||
Arguments: none
|
||||
Returns: pointer to the contiguous block of data
|
||||
*/
|
||||
|
||||
const unsigned char *
|
||||
pcre_maketables ()
|
||||
{
|
||||
unsigned char *yield, *p;
|
||||
int i;
|
||||
|
||||
yield = (unsigned char *) (pcre_malloc) (tables_length);
|
||||
if (yield == NULL)
|
||||
return NULL;
|
||||
p = yield;
|
||||
|
||||
/* First comes the lower casing table */
|
||||
for (i = 0; i < 256; i++)
|
||||
*p++ = tolower (i);
|
||||
|
||||
/* Next the case-flipping table */
|
||||
for (i = 0; i < 256; i++)
|
||||
*p++ = islower (i) ? toupper (i) : tolower (i);
|
||||
|
||||
/* Then the character class tables. Don't try to be clever and save effort
|
||||
on exclusive ones - in some locales things may be different. */
|
||||
memset (p, 0, cbit_length);
|
||||
for (i = 0; i < 256; i++)
|
||||
{
|
||||
if (isdigit (i))
|
||||
{
|
||||
p[cbit_digit + i / 8] |= 1 << (i & 7);
|
||||
p[cbit_word + i / 8] |= 1 << (i & 7);
|
||||
}
|
||||
if (isupper (i))
|
||||
{
|
||||
p[cbit_upper + i / 8] |= 1 << (i & 7);
|
||||
p[cbit_word + i / 8] |= 1 << (i & 7);
|
||||
}
|
||||
if (islower (i))
|
||||
{
|
||||
p[cbit_lower + i / 8] |= 1 << (i & 7);
|
||||
p[cbit_word + i / 8] |= 1 << (i & 7);
|
||||
}
|
||||
if (i == '_')
|
||||
p[cbit_word + i / 8] |= 1 << (i & 7);
|
||||
if (isspace (i))
|
||||
p[cbit_space + i / 8] |= 1 << (i & 7);
|
||||
if (isxdigit (i))
|
||||
p[cbit_xdigit + i / 8] |= 1 << (i & 7);
|
||||
if (isgraph (i))
|
||||
p[cbit_graph + i / 8] |= 1 << (i & 7);
|
||||
if (isprint (i))
|
||||
p[cbit_print + i / 8] |= 1 << (i & 7);
|
||||
if (ispunct (i))
|
||||
p[cbit_punct + i / 8] |= 1 << (i & 7);
|
||||
if (iscntrl (i))
|
||||
p[cbit_cntrl + i / 8] |= 1 << (i & 7);
|
||||
if (isblank (i))
|
||||
p[cbit_blank + i / 8] |= 1 << (i & 7);
|
||||
}
|
||||
p += cbit_length;
|
||||
|
||||
/* Finally, the character type table */
|
||||
for (i = 0; i < 256; i++)
|
||||
{
|
||||
int x = 0;
|
||||
if (isspace (i))
|
||||
x += ctype_space;
|
||||
if (isalpha (i))
|
||||
x += ctype_letter;
|
||||
if (isdigit (i))
|
||||
x += ctype_digit;
|
||||
if (isxdigit (i))
|
||||
x += ctype_xdigit;
|
||||
if (isalnum (i) || i == '_')
|
||||
x += ctype_word;
|
||||
if (i && strchr ("*+?{^.$|()[", i) != 0)
|
||||
x += ctype_meta;
|
||||
if (i == '\n')
|
||||
x += ctype_newline;
|
||||
*p++ = x;
|
||||
}
|
||||
|
||||
return yield;
|
||||
}
|
||||
+4
-3
@@ -1,8 +1,9 @@
|
||||
pcre/internal.h
|
||||
pcre/pcregrep.c
|
||||
pcre/regexp.c
|
||||
pcre/regstudy.c
|
||||
sed/compile.c
|
||||
sed/execute.c
|
||||
sed/regexp.c
|
||||
sed/sed.c
|
||||
lib/utils.c
|
||||
lib/regcomp.c
|
||||
lib/regexec.c
|
||||
lib/regex_internal.c
|
||||
@@ -6,7 +6,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.0.9\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2004-01-11 21:06+0000\n"
|
||||
"Last-Translator: Ysbeer <ysbeer@af.org.za>\n"
|
||||
"Language-Team: Afrikaans <i18n@af.org.za>\n"
|
||||
@@ -16,6 +16,206 @@ msgstr ""
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"Plural-Forms: nplurals=2; plural=n!=1;\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "Onbekende opsie vir `s'"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "leesfout op %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Ongeldige karakterklasnaam"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "Ongepaarde `{'"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "Onbekende opsie vir `s'"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Vermiste instruksie"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Regex te groot"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "opsie `e' word nie ondersteun nie"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Ongeldige inhoud binne \\{\\}"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -360,74 +560,47 @@ msgstr "leesfout op %s: %s"
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: Kan nie %s lees nie: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Sukses"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Sukses"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Geen paring"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Geen paring"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Ongeldige regex"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Ongeldige regex"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Ongeldige kollasiekarakter"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Ongeldige kollasiekarakter"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Ongeldige karakterklasnaam"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Sleep terugstreep"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Sleep terugstreep"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Ongeldige terugverwysing"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Ongeldige terugverwysing"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "Ongepaarde [ of [^"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "Ongepaarde [ of [^"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "Ongepaarde ( or \\("
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "Ongepaarde ( or \\("
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "Ongepaarde \\{"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "Ongepaarde \\{"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Ongeldige bereikseinde"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Ongeldige inhoud binne \\{\\}"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Geheue uitgeput"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Ongeldige bereikseinde"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Ongeldige vorige regex"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Geheue uitgeput"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Premature einde vir regex"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Ongeldige vorige regex"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "Ongepaarde ) of \\)"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Premature einde vir regex"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Regex te groot"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "Ongepaarde ) of \\)"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Geen vorige regex nie"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Geen vorige regex nie"
|
||||
@@ -6,7 +6,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.1.1\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2004-07-10 05:51+0200\n"
|
||||
"Last-Translator: Jordi Mallach <jordi@gnu.org>\n"
|
||||
"Language-Team: Catalan <ca@dodds.net>\n"
|
||||
@@ -15,6 +15,206 @@ msgstr ""
|
||||
"Content-Transfer-Encoding: 8bit\n"
|
||||
"Plural-Forms: nplurals=2; plural=n!=1;\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "opció desconeguda per a «s»"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "error de lectura en %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Nom de classe de caràcter no vàlid"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "«{» no emparellat"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "opció desconeguda per a «s»"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "cal una ordre"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "L'expressió regular és massa gran"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "l'opció «e» no està suportada"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "El contingut de \\{\\} no és vàlid"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
msgid "multiple `!'s"
|
||||
msgstr "múltiples «!»"
|
||||
@@ -373,74 +573,47 @@ msgstr "error de lectura en %s: %s"
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "no es pot reanomenar %s: %s"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Èxit"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Èxit"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Sense parella"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Sense parella"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Expressió regular no vàlida"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Expressió regular no vàlida"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "El caràcter de comparació no és vàlid"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "El caràcter de comparació no és vàlid"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Nom de classe de caràcter no vàlid"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Barra invertida al final"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Barra invertida al final"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "La referència cap enrere no és vàlida"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "La referència cap enrere no és vàlida"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "[ o [^ no emparellat"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "[ o [^ no emparellat"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "«(» o \\( no emparellat"
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "«(» o \\( no emparellat"
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "\\{ no emparellat"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "\\{ no emparellat"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "El rang final no és vàlid"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "El contingut de \\{\\} no és vàlid"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Memòria exhaurida"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "El rang final no és vàlid"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "L'expressió regular precedent no vàlida"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Memòria exhaurida"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Fi prematur de l'expressió regular"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "L'expressió regular precedent no vàlida"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr ") o \\) no emparellat"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Fi prematur de l'expressió regular"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "L'expressió regular és massa gran"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr ") o \\) no emparellat"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "No hi ha una expressió regular prèvia"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "No hi ha una expressió regular prèvia"
|
||||
@@ -5,7 +5,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 3.02.80\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2001-08-05 19:52+02:00\n"
|
||||
"Last-Translator: Vladimir Michl <Vladimir.Michl@seznam.cz>\n"
|
||||
"Language-Team: Czech <cs@li.org>\n"
|
||||
@@ -14,6 +14,202 @@ msgstr ""
|
||||
"Content-Transfer-Encoding: 8bit\n"
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "Neznámý pøepínaè pro `s'"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "chyba pøi ètení z %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "Neodpovídající `{'"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "Neznámý pøepínaè pro `s'"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Chybìjící pøíkaz"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
msgid "regular expression too large"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -348,78 +544,18 @@ msgstr "chyba p
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: %s nelze èíst: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
#, fuzzy
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "Neodpovídající `{'"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "Neodpovídající `{'"
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
#, fuzzy
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "Neodpovídající `{'"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "Neodpovídající `{'"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
#, fuzzy
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "Neodpovídající `{'"
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "Neodpovídající `{'"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
#, fuzzy
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "Neodpovídající `{'"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr ""
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "Neodpovídající `{'"
|
||||
@@ -5,7 +5,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.0.8\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2003-10-25 08:00+0200\n"
|
||||
"Last-Translator: Byrial Ole Jensen <byrial@image.dk>\n"
|
||||
"Language-Team: Danish <dansk@klid.dk>\n"
|
||||
@@ -15,6 +15,206 @@ msgstr ""
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"Plural-Forms: nplurals=2; plural=n != 1;\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "Ukendt tilvalg til 's'"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "læsefejl på %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Ugyldigt navn på tegnklasse"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "Uparret '{'"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "Ukendt tilvalg til 's'"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Der mangler en kommando"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Regulært udtryk for stort"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "tilvalg 'e' er ikke understøttet"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Ugyldigt indhold af \\{\\}"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -357,74 +557,47 @@ msgstr "l
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: kan ikke læse %s: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Godt resultat"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Godt resultat"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Intet resultat"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Intet resultat"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Ugyldigt regulært udtryk"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Ugyldigt regulært udtryk"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Ugyldigt sorteringstegn"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Ugyldigt sorteringstegn"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Ugyldigt navn på tegnklasse"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Afsluttende omvendt skråstreg"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Afsluttende omvendt skråstreg"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Ugyldig reference bagud"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Ugyldig reference bagud"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "Uparret [ eller [^"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "Uparret [ eller [^"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "Uparret ( eller \\("
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "Uparret ( eller \\("
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "Uparret \\{"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "Uparret \\{"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Ugyldig slutning på område"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Ugyldigt indhold af \\{\\}"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Hukommelsen opbrugt"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Ugyldig slutning på område"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Ugyldigt forudgående regulært udtryk"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Hukommelsen opbrugt"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Ufuldstændigt regulært udtryk"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Ugyldigt forudgående regulært udtryk"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "Uparret ) eller \\)"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Ufuldstændigt regulært udtryk"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Regulært udtryk for stort"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "Uparret ) eller \\)"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Intet forudgående regulært udtryk"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Intet forudgående regulært udtryk"
|
||||
@@ -5,7 +5,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.0.6\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2003-03-21 22:03:41+0100\n"
|
||||
"Last-Translator: Walter Koch <koch@u32.de>\n"
|
||||
"Language-Team: German <de@li.org>\n"
|
||||
@@ -15,6 +15,206 @@ msgstr ""
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "Unbekannte Option betreffs `s'"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "Lesefehler in %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Ungültige Zeichenklassenname"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "Nicht paarweises `{'"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "Unbekannte Option betreffs `s'"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Fehlender Befehl"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Regulärer Ausdruck ist zu groß"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "Option `e' wird nicht unterstützt"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Ungültiger Inhalt in \\{\\}"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -362,74 +562,47 @@ msgstr "Lesefehler in %s: %s"
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: kann %s nicht lesen: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Erfolgreich"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Erfolgreich"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Keine Übereinstimmung"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Keine Übereinstimmung"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Ungültiger regulärer Ausdruck"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Ungültiger regulärer Ausdruck"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Ungültiger Vergleichszeichen"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Ungültiger Vergleichszeichen"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Ungültige Zeichenklassenname"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Abschliessender Backslash"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Abschliessender Backslash"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Ungültiger Rückwärtsverweis"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Ungültiger Rückwärtsverweis"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "Nicht paarweises [ bzw. [^"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "Nicht paarweises [ bzw. [^"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "Nicht paarweises ( bzw. \\("
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "Nicht paarweises ( bzw. \\("
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "Nicht paarweises \\{"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "Nicht paarweises \\{"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Ungültiges Bereichende"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Ungültiger Inhalt in \\{\\}"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Speicher erschöpft"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Ungültiges Bereichende"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Vorheriger regulärer Ausdruck ist ungültig"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Speicher erschöpft"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Regulärer Ausdruck endet zu früh"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Vorheriger regulärer Ausdruck ist ungültig"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "Nicht paarweises ) bzw. \\)"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Regulärer Ausdruck endet zu früh"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Regulärer Ausdruck ist zu groß"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "Nicht paarweises ) bzw. \\)"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Kein vorheriger regulärer Ausdruck"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Kein vorheriger regulärer Ausdruck"
|
||||
@@ -5,7 +5,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: GNU sed 3.02.80\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2002-03-08 12:57+0000\n"
|
||||
"Last-Translator: Simos Xenitellis <simos@hellug.gr>\n"
|
||||
"Language-Team: Greek <nls@tux.hellug.gr>\n"
|
||||
@@ -14,6 +14,206 @@ msgstr ""
|
||||
"Content-Transfer-Encoding: 8bit\n"
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "¶ãíùóôç åðéëïãÞ ãéá ôï `s'"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "óöÜëìá áíÜãíùóçò óôï %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "ìç Ýãêõñï áêïëïõèßá äéáöõãÞò óå êëÜóç ÷áñáêôÞñùí"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "Áôáßñéáóôï `{'"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "¶ãíùóôç åðéëïãÞ ãéá ôï `s'"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Ëåßðåé ç åíôïëÞ"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "ðïëý ìåãÜëç êáíïíéêÞ Ýêöñáóç"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "äåí õðïóôçñßæåôáé ç åðéëïãÞ `e'"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "ìç Ýãêõñï ðåñéå÷üìåíï äåéêôþí åðáíÜëçøçò {}"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -351,85 +551,37 @@ msgstr "
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: áäõíáìßá óôçí áíÜãíùóç %s: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
#, fuzzy
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Äåí âñÝèçêå ðñïçãïýìåíç êáíïíéêÞ Ýêöñáóç"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Äåí âñÝèçêå ðñïçãïýìåíç êáíïíéêÞ Ýêöñáóç"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
#, fuzzy
|
||||
msgid "Invalid collation character"
|
||||
msgstr "ìç Ýãêõñï áêïëïõèßá äéáöõãÞò óå êëÜóç ÷áñáêôÞñùí"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "ìç Ýãêõñï áêïëïõèßá äéáöõãÞò óå êëÜóç ÷áñáêôÞñùí"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
#, fuzzy
|
||||
msgid "Invalid character class name"
|
||||
msgstr "ìç Ýãêõñï áêïëïõèßá äéáöõãÞò óå êëÜóç ÷áñáêôÞñùí"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "Áôáßñéáóôï `{'"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
#, fuzzy
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "Áôáßñéáóôï `{'"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "Áôáßñéáóôï `{'"
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
#, fuzzy
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "Áôáßñéáóôï `{'"
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "Áôáßñéáóôï `{'"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
#, fuzzy
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "Áôáßñéáóôï `{'"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Äåí âñÝèçêå ðñïçãïýìåíç êáíïíéêÞ Ýêöñáóç"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
#, fuzzy
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "ìç Ýãêõñï ðåñéå÷üìåíï äåéêôþí åðáíÜëçøçò {}"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Äåí âñÝèçêå ðñïçãïýìåíç êáíïíéêÞ Ýêöñáóç"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
#, fuzzy
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Äåí âñÝèçêå ðñïçãïýìåíç êáíïíéêÞ Ýêöñáóç"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "Áôáßñéáóôï `{'"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
#, fuzzy
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Äåí âñÝèçêå ðñïçãïýìåíç êáíïíéêÞ Ýêöñáóç"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
#, fuzzy
|
||||
msgid "Regular expression too big"
|
||||
msgstr "ðïëý ìåãÜëç êáíïíéêÞ Ýêöñáóç"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
#, fuzzy
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "Áôáßñéáóôï `{'"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Äåí âñÝèçêå ðñïçãïýìåíç êáíïíéêÞ Ýêöñáóç"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Äåí âñÝèçêå ðñïçãïýìåíç êáíïíéêÞ Ýêöñáóç"
|
||||
@@ -5,7 +5,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: GNU sed 4.0.8\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2003-10-26 20:57+0000\n"
|
||||
"Last-Translator: Edmund GRIMLEY EVANS <edmundo@rano.org>\n"
|
||||
"Language-Team: Esperanto <translation-team-eo@lists.sourceforge.net>\n"
|
||||
@@ -15,6 +15,206 @@ msgstr ""
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "Nekonata opcio por 's'"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "legeraro ĉe %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Nevalida nomo de signoklaso"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "Neparigita '{'"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "Nekonata opcio por 's'"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Mankas komando"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Regula esprimo tro granda"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "opcio 'e' ne realigita"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Nevalida enhavo de \\{\\}"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -357,74 +557,47 @@ msgstr "legeraro ĉe %s: %s"
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: ne povas legi %s: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Sukceso"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Sukceso"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Maltrafo"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Maltrafo"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Nevalida regula esprimo"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Nevalida regula esprimo"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Nevalida kunfanda signo"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Nevalida kunfanda signo"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Nevalida nomo de signoklaso"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Malsuprenstreko ĉe fino"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Malsuprenstreko ĉe fino"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Nevalida retroreferenco"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Nevalida retroreferenco"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "Neparigita [ aŭ [^"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "Neparigita [ aŭ [^"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "Neparigita ( aŭ \\("
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "Neparigita ( aŭ \\("
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "Neparigita \\{"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "Neparigita \\{"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Nevalida fino de gamo"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Nevalida enhavo de \\{\\}"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Mankas memoro"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Nevalida fino de gamo"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Nevalida antaŭa regula esprimo"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Mankas memoro"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Neatendita fino de regula esprimo"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Nevalida antaŭa regula esprimo"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "Neparigita ) aŭ \\)"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Neatendita fino de regula esprimo"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Regula esprimo tro granda"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "Neparigita ) aŭ \\)"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Mankas antaŭa regula esprimo"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Mankas antaŭa regula esprimo"
|
||||
@@ -5,7 +5,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.0.8\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2003-10-24 12:38-0500\n"
|
||||
"Last-Translator: Cristian Othón Martínez Vera <cfuga@itam.mx>\n"
|
||||
"Language-Team: Spanish <es@li.org>\n"
|
||||
@@ -15,6 +15,206 @@ msgstr ""
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "Opción desconocida para `s'"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "error al leer de %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Carácter de nombre de clase inválido"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "`{' sin pareja"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "Opción desconocida para `s'"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Orden faltante"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Expresión regular demasiado grande"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "no hay soporte para la opción `e'"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Contenido inválido de \\{\\}"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -360,74 +560,47 @@ msgstr "error al leer de %s: %s"
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: no se puede leer %s: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Éxito"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Éxito"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "No hay coincidencia"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "No hay coincidencia"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Expresion regular inválida"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Expresion regular inválida"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Carácter de ordenamiento inválido"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Carácter de ordenamiento inválido"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Carácter de nombre de clase inválido"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Diagonal invertida al final"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Diagonal invertida al final"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Referencia hacia atrás inválida"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Referencia hacia atrás inválida"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "[ ó [^ sin pareja"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "[ ó [^ sin pareja"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "( ó \\( sin pareja"
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "( ó \\( sin pareja"
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "\\{ sin pareja"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "\\{ sin pareja"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Final de rango inválido"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Contenido inválido de \\{\\}"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Memoria agotada"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Final de rango inválido"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Expresión regular precedente inválida"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Memoria agotada"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Final prematuro de la expresión regular"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Expresión regular precedente inválida"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr ") ó \\) sin pareja"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Final prematuro de la expresión regular"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Expresión regular demasiado grande"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr ") ó \\) sin pareja"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "No hay una expresión regular previa"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "No hay una expresión regular previa"
|
||||
@@ -5,7 +5,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.1.1\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2004-07-09 16:33+0300\n"
|
||||
"Last-Translator: Toomas Soome <Toomas.Soome@microlink.ee>\n"
|
||||
"Language-Team: Estonian <et@li.org>\n"
|
||||
@@ -14,6 +14,206 @@ msgstr ""
|
||||
"Content-Transfer-Encoding: 8-bit\n"
|
||||
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "tundmatu võti `s' käsule"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "lugemisviga %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Vigane sümbolite klassi nimi"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "liigne `{'"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "tundmatu võti `s' käsule"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "käsk puudub"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Regulaaravaldis on liiga suur"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "võtit `e' ei toetata"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Vigane \\{\\} sisu"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
msgid "multiple `!'s"
|
||||
msgstr "korduv `!'"
|
||||
@@ -363,74 +563,47 @@ msgstr "lugemisviga %s: %s"
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s ei saa ümber nimetada: %s"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Edukas"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Edukas"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Ei leia"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Ei leia"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Vigane regulaaravaldis"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Vigane regulaaravaldis"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Vigane sortimise sümbol"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Vigane sortimise sümbol"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Vigane sümbolite klassi nimi"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Lõpetav langkriips"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Lõpetav langkriips"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Vigane tagasi viide"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Vigane tagasi viide"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "Puudub [ või [^"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "Puudub [ või [^"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "Puudub ( või \\("
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "Puudub ( või \\("
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "Puudub \\{"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "Puudub \\{"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Vigane vahemiku lõpp"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Vigane \\{\\} sisu"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Mälu on otsas"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Vigane vahemiku lõpp"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Vigane eelnev regulaaravaldis"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Mälu on otsas"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Ootamatu regulaaravaldise lõpp"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Vigane eelnev regulaaravaldis"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "Puudub ) või \\)"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Ootamatu regulaaravaldise lõpp"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Regulaaravaldis on liiga suur"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "Puudub ) või \\)"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Eelmist regulaaravaldist pole"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Eelmist regulaaravaldist pole"
|
||||
@@ -5,7 +5,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed-4.0.8\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2003-12-07 09:35+0200\n"
|
||||
"Last-Translator: Sami J. Laine <sami.laine@iki.fi>\n"
|
||||
"Language-Team: Finnish <translation-team-fi@lists.sourceforge.net>\n"
|
||||
@@ -15,6 +15,206 @@ msgstr ""
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"Plural-Forms: nplurals=2; plural=n != 1;\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "Tuntematon valitsin \"s\":lle"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "lukuvirhe syötteessä %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Virhellinen merkkiluokan nimi"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "Pariton \"{\""
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "Tuntematon valitsin \"s\":lle"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Puuttuva komento"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Säännöllinen lauseke on liian suuri"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "valitsin `e' ei ole tuettu"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Virheellinen sisältö \\{\\}:ssä"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -360,74 +560,47 @@ msgstr "lukuvirhe sy
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: ei voida lukea syötettä %s: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Onnistui"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Onnistui"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Ei osumaa"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Ei osumaa"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Virheellinen säännöllinen lauseke"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Virheellinen säännöllinen lauseke"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Virheellinen vertailumerkki"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Virheellinen vertailumerkki"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Virhellinen merkkiluokan nimi"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Seuraava kenoviiva"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Seuraava kenoviiva"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Virheellinen takaisinviittaus"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Virheellinen takaisinviittaus"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "Pariton \"[\" tai \"[^\""
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "Pariton \"[\" tai \"[^\""
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "Pariton \"(\" tai \"\\(\""
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "Pariton \"(\" tai \"\\(\""
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "Pariton \"\\{\""
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "Pariton \"\\{\""
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Virheellinen välin loppu"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Virheellinen sisältö \\{\\}:ssä"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Muisti loppu"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Virheellinen välin loppu"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Virheellinen edeltävä säännöllinen lauseke"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Muisti loppu"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Ennenaikainen säännöllisen lausekkeen loppu"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Virheellinen edeltävä säännöllinen lauseke"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "Pariton \")\" tai \"\\)\""
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Ennenaikainen säännöllisen lausekkeen loppu"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Säännöllinen lauseke on liian suuri"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "Pariton \")\" tai \"\\)\""
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Ei aikaisempaa säännöllistä lausetta"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Ei aikaisempaa säännöllistä lausetta"
|
||||
@@ -9,7 +9,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.1.1\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2004-07-12 00:09+0200\n"
|
||||
"Last-Translator: Gaël Quéri <gael@lautre.net>\n"
|
||||
"Language-Team: French <traduc@traduc.org>\n"
|
||||
@@ -19,6 +19,206 @@ msgstr ""
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "option inconnue pour `s'"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "erreur de lecture sur %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Nom de classe de caractères invalide"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "`{' non refermée"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "option inconnue pour `s'"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "commande manquante"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Expression régulière trop grande"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "l'option `e' n'est pas supportée"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Contenu de \\{\\} invalide"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
msgid "multiple `!'s"
|
||||
msgstr "`!' multiples"
|
||||
@@ -380,74 +580,47 @@ msgstr "erreur de lecture sur %s: %s"
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "impossible de renommer %s: %s"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Succès"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Succès"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Pas de concordance"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Pas de concordance"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Expression régulière invalide"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Expression régulière invalide"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Caractère de collation invalide"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Caractère de collation invalide"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Nom de classe de caractères invalide"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Antislash de protection"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Antislash de protection"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Référence arrière invalide"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Référence arrière invalide"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "[ ou [^ non refermé"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "[ ou [^ non refermé"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "( ou \\( non refermé"
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "( ou \\( non refermé"
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "\\{ non refermé"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "\\{ non refermé"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Fin d'intervalle invalide"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Contenu de \\{\\} invalide"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Mémoire épuisée"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Fin d'intervalle invalide"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "L'expression régulière précédente est invalide"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Mémoire épuisée"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Fin prématurée d'une expression régulière"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "L'expression régulière précédente est invalide"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr ") ou \\) non refermé"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Fin prématurée d'une expression régulière"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Expression régulière trop grande"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr ") ou \\) non refermé"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Pas d'expression régulière précédente"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Pas d'expression régulière précédente"
|
||||
@@ -5,7 +5,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.1.1\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2004-07-07 11:04-0500\n"
|
||||
"Last-Translator: Kevin Patrick Scannell <scannell@SLU.EDU>\n"
|
||||
"Language-Team: Irish <ga@li.org>\n"
|
||||
@@ -15,6 +15,206 @@ msgstr ""
|
||||
"Plural-Forms: nplurals=4; plural=n==1 ? 0 : (n>1 && n<7) ? 1 : (n>6 && n "
|
||||
"<11) ? 2 : 3;\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "rogha anaithnid i ndiaidh `s'"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "earráid ag léamh %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Aicme charachtair neamhbhailí"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "`{' corr"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "rogha anaithnid i ndiaidh `s'"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "ordú ar iarraidh"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Slonn ionadaíochta rómhór"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "níl an rogha `e' ar fáil"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Ábhar neamhbhailí idir \\{\\}"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
msgid "multiple `!'s"
|
||||
msgstr "`!'-anna iomadúla"
|
||||
@@ -372,75 +572,48 @@ msgstr "earr
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "ní féidir %s a athainmniú: %s"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Bua!"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Bua!"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Níl a leithéid ann"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Níl a leithéid ann"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Slonn ionadaíochta neamhbhailí"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Slonn ionadaíochta neamhbhailí"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Carachtar cóimheasa neamhbhailí"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Carachtar cóimheasa neamhbhailí"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Aicme charachtair neamhbhailí"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Cúlslais ag deireadh"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Cúlslais ag deireadh"
|
||||
|
||||
# coinage - KPS
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Cúltagairt neamhbhailí"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Cúltagairt neamhbhailí"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "[ nó [^ corr"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "[ nó [^ corr"
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "( nó \\( corr"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "( nó \\( corr"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "\\{ corr"
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "\\{ corr"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Ábhar neamhbhailí idir \\{\\}"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Deireadh raoin neamhbhailí"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Deireadh raoin neamhbhailí"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Cuimhne ídithe"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Cuimhne ídithe"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Is neamhbhailí an slonn ionadaíochta roimh seo"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Is neamhbhailí an slonn ionadaíochta roimh seo"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Deireadh le slonn ionadaíochta gan choinne"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Deireadh le slonn ionadaíochta gan choinne"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr ") nó \\) corr"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Slonn ionadaíochta rómhór"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr ") nó \\) corr"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Níl aon slonn ionadaíochta roimh seo"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Níl aon slonn ionadaíochta roimh seo"
|
||||
@@ -5,7 +5,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.0\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2002-10-25 15:57+0200\n"
|
||||
"Last-Translator: Jacobo Tarrío Barreiro <jtarrio@trasno.net>\n"
|
||||
"Language-Team: Galician <gpul-traduccion@ceu.fi.udc.es>\n"
|
||||
@@ -15,6 +15,206 @@ msgstr ""
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"Plural-Forms: nplurals=2; plural=n!=1;\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "Opción de `s' descoñecida"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "erro de lectura en %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Nome de clase de caracteres non válido"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "`{' sen parella"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "Opción de `s' descoñecida"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Falta unha instrucción"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Expresión regular grande de máis"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "a opción `e' non está soportada"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Contido de \\{\\} non válido"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -360,74 +560,47 @@ msgstr "erro de lectura en %s: %s"
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: non se puido ler %s: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Éxito"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Éxito"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Non se atopou"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Non se atopou"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Expresión regular non válida"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Expresión regular non válida"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Carácter de ordeamento non válido"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Carácter de ordeamento non válido"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Nome de clase de caracteres non válido"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Barra invertida á fin de liña"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Barra invertida á fin de liña"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Referencia cara a atrás non válida"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Referencia cara a atrás non válida"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "[ ou [^ sen parella"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "[ ou [^ sen parella"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "( ou \\( sen parella"
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "( ou \\( sen parella"
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "\\{ sen parella"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "\\{ sen parella"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Fin de rango non válida"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Contido de \\{\\} non válido"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Memoria esgotada"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Fin de rango non válida"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Expresión regular anterior non válida"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Memoria esgotada"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Fin prematura da expresión regular"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Expresión regular anterior non válida"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr ") ou \\) sen parella"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Fin prematura da expresión regular"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Expresión regular grande de máis"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr ") ou \\) sen parella"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Non hai unha expresión regular anterior"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Non hai unha expresión regular anterior"
|
||||
@@ -5,7 +5,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 3.02.80\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2001-08-04 20:37+0300\n"
|
||||
"Last-Translator: Eli Zaretskii <eliz@gnu.org>\n"
|
||||
"Language-Team: Hebrew <eliz@gnu.org>\n"
|
||||
@@ -14,6 +14,202 @@ msgstr ""
|
||||
"Content-Transfer-Encoding: 8-bit\n"
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "`s' ìù øëåî-éúìá ïééôàî"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "%s úàéø÷á (%s) äì÷ú"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "âåæ-ïá åì ïéàù `{'"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "`s' ìù øëåî-éúìá ïééôàî"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "äøñç äãå÷ô"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
msgid "regular expression too large"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -346,78 +542,18 @@ msgstr "%s
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s úéðëúá %s úàéø÷á (%s) äàéâù\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
#, fuzzy
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "âåæ-ïá åì ïéàù `{'"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "âåæ-ïá åì ïéàù `{'"
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
#, fuzzy
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "âåæ-ïá åì ïéàù `{'"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "âåæ-ïá åì ïéàù `{'"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
#, fuzzy
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "âåæ-ïá åì ïéàù `{'"
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "âåæ-ïá åì ïéàù `{'"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
#, fuzzy
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "âåæ-ïá åì ïéàù `{'"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr ""
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "âåæ-ïá åì ïéàù `{'"
|
||||
@@ -5,7 +5,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 3.02a\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2002-06-14 15:17-01\n"
|
||||
"Last-Translator: Denis Lackovic <delacko@fly.srk.fer.hr>\n"
|
||||
"Language-Team: Croatian <lokalizacija@linux.hr>\n"
|
||||
@@ -16,6 +16,203 @@ msgstr ""
|
||||
"Plural-Forms: nplurals=2; plural=(n==1?0:1);\n"
|
||||
"X-Generator: TransDict server\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "Nepoznata opcija za `s'"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "Greška u čitanju na %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "Neuparena `{'"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "Nepoznata opcija za `s'"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Nedostaje naredba"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Nedostaje prethodni regularni izraz"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -350,82 +547,33 @@ msgstr "Greška u čitanju na %s: %s"
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: ne mogu čitati %s: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
#, fuzzy
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Nedostaje prethodni regularni izraz"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Nedostaje prethodni regularni izraz"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
#, fuzzy
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "Neuparena `{'"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "Neuparena `{'"
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
#, fuzzy
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "Neuparena `{'"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "Neuparena `{'"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
#, fuzzy
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "Neuparena `{'"
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "Neuparena `{'"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
#, fuzzy
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Nedostaje prethodni regularni izraz"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Nedostaje prethodni regularni izraz"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
#, fuzzy
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Nedostaje prethodni regularni izraz"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Nedostaje prethodni regularni izraz"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
#, fuzzy
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Nedostaje prethodni regularni izraz"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "Neuparena `{'"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
#, fuzzy
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "Neuparena `{'"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Nedostaje prethodni regularni izraz"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Nedostaje prethodni regularni izraz"
|
||||
@@ -5,7 +5,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.0.8\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2003-10-26 09:28+0100\n"
|
||||
"Last-Translator: Mihály Gyulai <gyulai@fbi.hu>\n"
|
||||
"Language-Team: Hungarian <translation-team-hu@lists.sourceforge.net>\n"
|
||||
@@ -15,6 +15,206 @@ msgstr ""
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"Plural-Forms: nplurals=1; plural=0;\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "Ismeretlen `s' opció"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "olvasási hiba %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Érvénytelen karakterosztály-név"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "Nincs párban `{'"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "Ismeretlen `s' opció"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Hiányzó parancs"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Túl nagy reguláris kifejezés"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "az `e' opció nincs támogatva"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "\\{\\}-nak érvénytelen a tartalma"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -358,74 +558,47 @@ msgstr "olvas
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: nem lehet olvasni %s: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Sikeres"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Sikeres"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Nincs találat"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Nincs találat"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Hibás reguláris kifejezés"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Hibás reguláris kifejezés"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Érvénytelen összehasonlító karakter"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Érvénytelen összehasonlító karakter"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Érvénytelen karakterosztály-név"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Lezáró visszaperjel"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Lezáró visszaperjel"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Érvénytelen vissza-hivatkozás"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Érvénytelen vissza-hivatkozás"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "Nincs párban [ vagy [^"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "Nincs párban [ vagy [^"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "Nincs párban ( vagy \\("
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "Nincs párban ( vagy \\("
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "Nincs párban \\{"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "Nincs párban \\{"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Sorozat érvénytelen vége"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "\\{\\}-nak érvénytelen a tartalma"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Kevés a memória"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Sorozat érvénytelen vége"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Érvénytelen megelõzõ reguláris kifejezés"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Kevés a memória"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Reguláris kifejezés túl korai vége"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Érvénytelen megelõzõ reguláris kifejezés"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "Nincs párban ) vagy \\)"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Reguláris kifejezés túl korai vége"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Túl nagy reguláris kifejezés"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "Nincs párban ) vagy \\)"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Nincsen elõzõ reguláris kifejezés"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Nincsen elõzõ reguláris kifejezés"
|
||||
@@ -6,7 +6,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.0.9\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2004-04-27 14:56+0700\n"
|
||||
"Last-Translator: Tedi Heriyanto <tedi_h@gmx.net>\n"
|
||||
"Language-Team: Indonesian <translation-team-id@lists.sourceforge.net>\n"
|
||||
@@ -16,6 +16,206 @@ msgstr ""
|
||||
"Plural-Forms: nplurals=1; plural=0;\n"
|
||||
"X-Generator: KBabel 1.3\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "Opsion tidak dikenal bagi `s'"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "kesalahan pembacaan pada %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Nama kelas karakter tidak valid"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "`{' tidak sesuai"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "Opsion tidak dikenal bagi `s'"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Perintah hilang"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Reguler ekspresi terlalu besar"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "option `e' tidak didukung"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Isi \\{\\} tidak valid"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -358,74 +558,47 @@ msgstr "kesalahan pembacaan pada %s: %s"
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: tidak dapat membaca %s: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Sukses"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Sukses"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Tidak cocok"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Tidak cocok"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Reguler ekspresi tidak valid"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Reguler ekspresi tidak valid"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Karakter kolasi tidak valid"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Karakter kolasi tidak valid"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Nama kelas karakter tidak valid"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Trailing backslash"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Trailing backslash"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Referensi balik tidak valid"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Referensi balik tidak valid"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "[ atau [^ tidak sesuai"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "[ atau [^ tidak sesuai"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "( atau \\( tidak sesuai"
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "( atau \\( tidak sesuai"
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "\\{ tidak sesuai"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "\\{ tidak sesuai"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Akhir batas tidak valid"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Isi \\{\\} tidak valid"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Memori habis"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Akhir batas tidak valid"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Reguler ekspresi sebelumnya tidak valid"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Memori habis"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Akhir reguler ekspresi prematur"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Reguler ekspresi sebelumnya tidak valid"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr ") atau \\) tidak sesuai"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Akhir reguler ekspresi prematur"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Reguler ekspresi terlalu besar"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr ") atau \\) tidak sesuai"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Tidak ada reguler ekspresi sebelumnya"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Tidak ada reguler ekspresi sebelumnya"
|
||||
@@ -1,124 +1,291 @@
|
||||
# traduzione di sed
|
||||
# Copyright (C) 1999 Free Software Foundation, Inc.
|
||||
# Paolo Bonzini <bonzini@gnu.org>, 2001
|
||||
#
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.0a\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"PO-Revision-Date: 2002-11-26 12:44+0100\n"
|
||||
"Project-Id-Version: ssed 3.46\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2000-12-21 12:44+0100\n"
|
||||
"Last-Translator: Paolo Bonzini <bonzini@gnu.org>\n"
|
||||
"Language-Team: Italian <tp@lists.linux.it>\n"
|
||||
"Language-Team: Italian <it@li.org>\n"
|
||||
"MIME-Version: 1.0\n"
|
||||
"Content-Type: text/plain; charset=ISO-8859-1\n"
|
||||
"Content-Transfer-Encoding: 8-bit\n"
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"Plural-Forms: nplurals=2; plural=n != 1;\n"
|
||||
|
||||
# sed/compile.c:166
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr "Utilizzo: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "pcregrep: opzione %c sconosciuta\n"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr "pcregrep: errore nell'espressione alla posizione %d: %s\n"
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr "pcregrep: errore nell'analisi dell'espressione: %s\n"
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "pcregrep: impossibile aprire %s: %s\n"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr "\\ alla fine dell'espressione"
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr "\\c alla fine dell'espressione"
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr "carattere non riconosciuto dopo \\"
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr "i numeri dentro le graffe non sono in ordine"
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr "un numero dentro le graffe e' troppo grande"
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr "manca una quadra chiusa"
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "sequenza di escape non valida tra parentesi quadre"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr "intervallo di caratteri non valido tra parentesi quadre"
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr "operatore di ripetizione al posto sbagliato"
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr "un atomo ripetibile indefinitamente potrebbe essere vuoto"
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr "errore interno: comando di ripetizione inatteso"
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr "carattere non riconosciuto dopo (?"
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr "errore inutilizzato"
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
msgid "unmatched braces"
|
||||
msgstr "manca una graffa chiusa"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr "riferimento all'indietro non valido (subpattern inesistente)"
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr "il parametro erroffset e' NULL"
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "sono impostati dei bit di opzione sconosciuti"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
msgid "missing ) after comment"
|
||||
msgstr "manca una parentesi di chiusura di un commento"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr "parentesi troppo annidate"
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
msgid "regular expression too large"
|
||||
msgstr "espressione troppo grande"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr "memoria esaurita"
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr "manca una parentesi chiusa"
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr "errore interno di compilazione"
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr "carattere non riconosciuto dopo (?<"
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr "i controlli all'indietro devono avere lunghezza fissa"
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr "numero non valido dopo (?("
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr "piu' di due divisioni in un gruppo condizionale"
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr "atteso numero associato a una condizione dopo (?("
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr "(?p non seguito da )"
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr "nome POSIX di classe di caratteri sconosciuto"
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "le specifiche di caratteri speciali non sono supportate"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr "condizione (?(0) non valida"
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr "errore interno"
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "numero di ripetizioni specificato tra graffe non valido"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr "errore nell'espressione regolare"
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr "specifica di caratteri speciali non valida"
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr "sequenza di escape non valida"
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr "l'espressione regolare non e' valida"
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr "argomento non valido"
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr "espressione non trovata"
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr "errore sconosciuto"
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr "%s alla posizione %-6d"
|
||||
|
||||
#: sed/compile.c:162
|
||||
msgid "multiple `!'s"
|
||||
msgstr "`!' multipli"
|
||||
|
||||
# sed/compile.c:167
|
||||
#: sed/compile.c:163
|
||||
msgid "unexpected `,'"
|
||||
msgstr "`,' inattesa"
|
||||
|
||||
# sed/compile.c:169
|
||||
#: sed/compile.c:164
|
||||
msgid "invalid usage of +N or ~N as first address"
|
||||
msgstr "impossibile usare +N o ~N come primo indirizzo"
|
||||
msgstr "Impossibile usare +N o ~N come primo indirizzo"
|
||||
|
||||
# sed/compile.c:170
|
||||
#: sed/compile.c:165
|
||||
msgid "unmatched `{'"
|
||||
msgstr "`{' non bilanciata"
|
||||
|
||||
# sed/compile.c:171
|
||||
#: sed/compile.c:166
|
||||
msgid "unexpected `}'"
|
||||
msgstr "`}' inattesa"
|
||||
|
||||
# sed/compile.c:172
|
||||
#: sed/compile.c:167
|
||||
msgid "extra characters after command"
|
||||
msgstr "ci sono altri caratteri dopo il comando"
|
||||
|
||||
# sed/compile.c:173
|
||||
#: sed/compile.c:168
|
||||
msgid "expected \\ after `a', `c' or `i'"
|
||||
msgstr "atteso \\ dopo `a', `c' o `i'"
|
||||
|
||||
# sed/compile.c:174
|
||||
#: sed/compile.c:169
|
||||
msgid "`}' doesn't want any addresses"
|
||||
msgstr "`}' non accetta indirizzi"
|
||||
|
||||
# sed/compile.c:175
|
||||
#: sed/compile.c:170
|
||||
msgid ": doesn't want any addresses"
|
||||
msgstr ": non accetta indirizzi"
|
||||
|
||||
# sed/compile.c:176
|
||||
#: sed/compile.c:171
|
||||
msgid "comments don't accept any addresses"
|
||||
msgstr "i commenti non accettano indirizzi"
|
||||
|
||||
# sed/compile.c:177
|
||||
#: sed/compile.c:172
|
||||
msgid "missing command"
|
||||
msgstr "manca il comando"
|
||||
|
||||
# sed/compile.c:178
|
||||
#: sed/compile.c:173
|
||||
msgid "command only uses one address"
|
||||
msgstr "il comando usa solo un indirizzo"
|
||||
|
||||
# sed/compile.c:179
|
||||
#: sed/compile.c:174
|
||||
msgid "unterminated address regex"
|
||||
msgstr "espressione regolare non terminata nell'indirizzo"
|
||||
msgstr "indirizzo della regex non terminato"
|
||||
|
||||
# sed/compile.c:180
|
||||
#: sed/compile.c:175
|
||||
msgid "unterminated `s' command"
|
||||
msgstr "comando `s' non terminato"
|
||||
|
||||
# sed/compile.c:181
|
||||
#: sed/compile.c:176
|
||||
msgid "unterminated `y' command"
|
||||
msgstr "comando `y' non terminato"
|
||||
|
||||
# sed/compile.c:182
|
||||
#: sed/compile.c:177
|
||||
msgid "unknown option to `s'"
|
||||
msgstr "opzione di `s' sconosciuta"
|
||||
|
||||
# sed/compile.c:183
|
||||
#: sed/compile.c:178
|
||||
msgid "multiple `p' options to `s' command"
|
||||
msgstr "opzioni `p' multiple al comando `s'"
|
||||
|
||||
# sed/compile.c:184
|
||||
#: sed/compile.c:179
|
||||
msgid "multiple `g' options to `s' command"
|
||||
msgstr "opzioni `g' multiple al comando `s'"
|
||||
|
||||
# sed/compile.c:186
|
||||
#: sed/compile.c:180
|
||||
msgid "multiple number options to `s' command"
|
||||
msgstr "opzioni numeriche multiple al comando `s'"
|
||||
|
||||
# sed/compile.c:188
|
||||
#: sed/compile.c:181
|
||||
msgid "number option to `s' command may not be zero"
|
||||
msgstr "l'opzione numerica del comando `s' non può essere zero"
|
||||
|
||||
# sed/compile.c:190
|
||||
#: sed/compile.c:182
|
||||
msgid "strings for `y' command are different lengths"
|
||||
msgstr "le stringhe per il comandi `y' hanno lunghezze diverse"
|
||||
msgstr "le stringhe per i comandi `y' hanno lunghezze diverse"
|
||||
|
||||
#: sed/compile.c:183
|
||||
msgid "delimiter character is not a single-byte character"
|
||||
@@ -128,90 +295,75 @@ msgstr "il carattere delimitatore
|
||||
msgid "expected newer version of sed"
|
||||
msgstr "attesa una versione piu' recente di sed"
|
||||
|
||||
# sed/compile.c:178
|
||||
#: sed/compile.c:185
|
||||
msgid "invalid usage of line address 0"
|
||||
msgstr "utilizzo non valido dell'indirizzo 0"
|
||||
msgstr "uso non valido della linea 0"
|
||||
|
||||
# sed/compile.c:1319
|
||||
#: sed/compile.c:186
|
||||
#, c-format
|
||||
msgid "unknown command: `%c'"
|
||||
msgstr "comando sconosciuto: `%c'"
|
||||
|
||||
# sed/compile.c:1340
|
||||
#: sed/compile.c:209
|
||||
#, c-format
|
||||
msgid "%s: file %s line %lu: %s\n"
|
||||
msgstr "%s: file %s riga %lu: %s\n"
|
||||
|
||||
# sed/compile.c:1343
|
||||
#: sed/compile.c:212
|
||||
#, c-format
|
||||
msgid "%s: -e expression #%lu, char %lu: %s\n"
|
||||
msgstr "%s: espressione -e #%lu, carattere %lu: %s\n"
|
||||
|
||||
# sed/compile.c:1543
|
||||
#: sed/compile.c:1644
|
||||
#, c-format
|
||||
msgid "can't find label for jump to `%s'"
|
||||
msgstr "impossibile trovare un'etichetta per il salto a `%s'"
|
||||
|
||||
# sed/execute.c:516
|
||||
#: sed/execute.c:649
|
||||
#, c-format
|
||||
msgid "%s: can't read %s: %s\n"
|
||||
msgstr "%s: impossibile leggere %s: %s\n"
|
||||
|
||||
# sed/execute.c:675
|
||||
#: sed/execute.c:672
|
||||
#, c-format
|
||||
msgid "couldn't edit %s: is a terminal"
|
||||
msgstr "impossibile modificare %s: è un terminale"
|
||||
msgstr "impossibile modificare il file %s: è un terminale"
|
||||
|
||||
#: sed/execute.c:676
|
||||
#, c-format
|
||||
msgid "couldn't edit %s: not a regular file"
|
||||
msgstr "impossibile modificare %s: non è un file normale"
|
||||
msgstr "impossibile modificare il file %s: non è un file regolare"
|
||||
|
||||
# lib/utils.c:131
|
||||
#: sed/execute.c:683 lib/utils.c:196
|
||||
#, c-format
|
||||
msgid "couldn't open temporary file %s: %s"
|
||||
msgstr "impossibile aprire il file temporaneo %s: %s"
|
||||
|
||||
# sed/execute.c:1003 sed/execute.c:1183
|
||||
#: sed/execute.c:1207 sed/execute.c:1388
|
||||
msgid "error in subprocess"
|
||||
msgstr "errore in un sottoprocesso"
|
||||
|
||||
# sed/execute.c:1005
|
||||
#: sed/execute.c:1209
|
||||
msgid "option `e' not supported"
|
||||
msgstr "opzione `e' non supportata"
|
||||
|
||||
# sed/execute.c:1185
|
||||
#: sed/execute.c:1390
|
||||
msgid "`e' command not supported"
|
||||
msgstr "comando `e' non supportato"
|
||||
|
||||
# lib/regcomp.c:658 sed/regex.c:47
|
||||
#: sed/regexp.c:39
|
||||
msgid "no previous regular expression"
|
||||
msgstr "occorre un'espressione regolare precedente"
|
||||
|
||||
# sed/regex.c:48
|
||||
#: sed/regexp.c:40
|
||||
msgid "cannot specify modifiers on empty regexp"
|
||||
msgstr "non è possibile specificare dei modificatori per l'espressione vuota"
|
||||
|
||||
# sed/regex.c:146
|
||||
#: sed/regexp.c:134
|
||||
#, c-format
|
||||
msgid "invalid reference \\%d on `s' command's RHS"
|
||||
msgstr "riferimento non valido \\%d nel secondo membro del comando `s'"
|
||||
|
||||
# sed/sed.c:98
|
||||
#: sed/sed.c:96
|
||||
msgid ""
|
||||
" -R, --regexp-perl\n"
|
||||
@@ -282,7 +434,6 @@ msgstr ""
|
||||
" --posix\n"
|
||||
" disabilita tutte le estensioni GNU.\n"
|
||||
|
||||
# sed/sed.c:98
|
||||
#: sed/sed.c:117
|
||||
msgid ""
|
||||
" -r, --regexp-extended\n"
|
||||
@@ -338,7 +489,6 @@ msgstr ""
|
||||
"sono specificati file di input sarà letto lo standard input.\n"
|
||||
"\n"
|
||||
|
||||
# sed/sed.c:132
|
||||
#: sed/sed.c:134
|
||||
#, c-format
|
||||
msgid ""
|
||||
@@ -348,13 +498,11 @@ msgstr ""
|
||||
"Segnalare eventuali bug a: %s .\n"
|
||||
"Assicurarsi di includere la parola ``%s'' nell'oggetto del messaggio.\n"
|
||||
|
||||
# sed/sed.c:255
|
||||
#: sed/sed.c:271
|
||||
#, c-format
|
||||
msgid "super-sed version %s\n"
|
||||
msgstr "super-sed versione %s\n"
|
||||
|
||||
# sed/sed.c:256
|
||||
#: sed/sed.c:272
|
||||
#, c-format
|
||||
msgid ""
|
||||
@@ -364,13 +512,11 @@ msgstr ""
|
||||
"basato su GNU sed versione %s\n"
|
||||
"\n"
|
||||
|
||||
# sed/sed.c:258
|
||||
#: sed/sed.c:274
|
||||
#, c-format
|
||||
msgid "GNU sed version %s\n"
|
||||
msgstr "GNU sed versione %s\n"
|
||||
|
||||
# sed/sed.c:260
|
||||
#: sed/sed.c:276
|
||||
#, c-format
|
||||
msgid ""
|
||||
@@ -385,124 +531,29 @@ msgstr ""
|
||||
"NON c'è garanzia; neppure di COMMERCIABILITA' o IDONEITA' AD UN PARTICOLARE\n"
|
||||
"SCOPO, nei limiti permessi dalla legge.\n"
|
||||
|
||||
# sed/execute.c:516
|
||||
#: lib/utils.c:98 lib/utils.c:336
|
||||
#, c-format
|
||||
msgid "cannot remove %s: %s"
|
||||
msgstr "impossibile rimuovere %s: %s"
|
||||
msgstr "impossibile eliminare %s: %s"
|
||||
|
||||
# lib/utils.c:131
|
||||
#: lib/utils.c:143
|
||||
#, c-format
|
||||
msgid "couldn't open file %s: %s"
|
||||
msgstr "impossibile aprire il file %s: %s"
|
||||
|
||||
# lib/utils.c:161
|
||||
#: lib/utils.c:220
|
||||
#, c-format
|
||||
msgid "couldn't write %d item to %s: %s"
|
||||
msgid_plural "couldn't write %d items to %s: %s"
|
||||
msgstr[0] "Impossibile scrivere %d elemento su %s: %s"
|
||||
msgstr[1] "Impossibile scrivere %d elementi su %s: %s"
|
||||
msgstr[0] "impossibile scrivere %d elemento su %s: %s"
|
||||
msgstr[1] "impossibile scrivere %d elementi su %s: %s"
|
||||
|
||||
# lib/utils.c:176
|
||||
#: lib/utils.c:235 lib/utils.c:251
|
||||
#, c-format
|
||||
msgid "read error on %s: %s"
|
||||
msgstr "errore di lettura su %s: %s"
|
||||
|
||||
# sed/execute.c:516
|
||||
#: lib/utils.c:341
|
||||
#, c-format
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "impossibile rinominare %s: %s"
|
||||
|
||||
# lib/regcomp.c:179
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Successo"
|
||||
|
||||
# lib/regcomp.c:182
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Nessuna corrispondenza trovata"
|
||||
|
||||
# lib/regcomp.c:185
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Espressione regolare non valida"
|
||||
|
||||
# lib/regcomp.c:188
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Carattere di ordinamento non valido"
|
||||
|
||||
# lib/regcomp.c:191
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Nome non valido per una classe di caratteri"
|
||||
|
||||
# lib/regcomp.c:194
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Barra rovesciata alla fine dell'espressione regolare"
|
||||
|
||||
# lib/regcomp.c:197
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Riferimento non valido"
|
||||
|
||||
# lib/regcomp.c:200
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "`[' non bilanciata"
|
||||
|
||||
# lib/regcomp.c:203
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "`(' o `\\(' non bilanciata"
|
||||
|
||||
# lib/regcomp.c:206
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "`\\{' non bilanciata"
|
||||
|
||||
# lib/regcomp.c:209
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "numero di ripetizioni specificato tra graffe non valido"
|
||||
|
||||
# lib/regcomp.c:212
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Fine dell'intervallo non valida"
|
||||
|
||||
# lib/regcomp.c:215
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Memoria esaurita"
|
||||
|
||||
# lib/regcomp.c:218
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Espressione regolare precedente non valida"
|
||||
|
||||
# lib/regcomp.c:221
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Fine prematura dell'espressione regolare"
|
||||
|
||||
# lib/regcomp.c:224
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Espressione regolare troppo grande"
|
||||
|
||||
# lib/regcomp.c:227
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "`)' o `\\)' non bilanciata"
|
||||
|
||||
# lib/regcomp.c:658 sed/regex.c:47
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Occorre un'espressione regolare precedente"
|
||||
@@ -9,7 +9,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: GNU sed 4.0.6\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2004-04-21 23:53+0900\n"
|
||||
"Last-Translator: IIDA Yosiaki <iida@gnu.org>\n"
|
||||
"Language-Team: Japanese <translation-team-ja@lists.sourceforge.net>\n"
|
||||
@@ -19,6 +19,206 @@ msgstr ""
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"Plural-Forms: nplurals=1; plural=0;\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "`s'へのオプションが不明です"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "%sの読込みエラー: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "無効な文字クラス名"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "`{'が釣合いません"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "`s'へのオプションが不明です"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "コマンドが足りません"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "大き過ぎる正規表現"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "eオプションは、サポートされていません"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "無効な\\{\\}の内容\""
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -371,74 +571,47 @@ msgstr "%s
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: %sを読み込めません: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "成功"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "成功"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "照合しません"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "照合しません"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "無効な正規表現"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "無効な正規表現"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "無効な校合文字"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "無効な校合文字"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "無効な文字クラス名"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "後続の逆スラッシュ"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "後続の逆スラッシュ"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "無効な逆参照"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "無効な逆参照"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "[や[^が釣合いません"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "[や[^が釣合いません"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "(や\\(が釣合いません"
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "(や\\(が釣合いません"
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "\\{が釣合いません"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "\\{が釣合いません"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "無効な範囲の終端"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "無効な\\{\\}の内容\""
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "メモリーが足りません"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "無効な範囲の終端"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "無効な先行正規表現"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "メモリーが足りません"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "予期せぬ正規表現の終端"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "無効な先行正規表現"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr ")や\\)が一致しません"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "予期せぬ正規表現の終端"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "大き過ぎる正規表現"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr ")や\\)が一致しません"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "直前の正規表現が、ありません"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "直前の正規表現が、ありません"
|
||||
@@ -5,7 +5,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: GNU sed 3.02.80\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2001-10-12 17:26+0900\n"
|
||||
"Last-Translator: Jong-Hoon Ryu <redhat4u@netian.com>\n"
|
||||
"Language-Team: Korean <ko@li.org>\n"
|
||||
@@ -14,6 +14,202 @@ msgstr ""
|
||||
"Content-Transfer-Encoding: 8bit\n"
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "`s' 에 알 수 없는 옵션이 있습니다"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "%s 의 내용 읽기 오류: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "`{' 가 일치하지 않습니다"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "`s' 에 알 수 없는 옵션이 있습니다"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "명령이 지정되지 않았습니다"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
msgid "regular expression too large"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -346,78 +542,18 @@ msgstr "%s
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: %s (을)를 읽을 수 없음: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
#, fuzzy
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "`{' 가 일치하지 않습니다"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "`{' 가 일치하지 않습니다"
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
#, fuzzy
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "`{' 가 일치하지 않습니다"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "`{' 가 일치하지 않습니다"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
#, fuzzy
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "`{' 가 일치하지 않습니다"
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "`{' 가 일치하지 않습니다"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
#, fuzzy
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "`{' 가 일치하지 않습니다"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr ""
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "`{' 가 일치하지 않습니다"
|
||||
@@ -7,7 +7,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.0.9\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2004-04-09 21:39+0200\n"
|
||||
"Last-Translator: Elros Cyriatan <cyriatan@fastmail.fm>\n"
|
||||
"Language-Team: Dutch <vertaling@nl.linux.org>\n"
|
||||
@@ -17,6 +17,206 @@ msgstr ""
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"Plural-Forms: nplurals=2; plural=n != 1;\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "Onbekende optie voor `s'"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "leesfout op %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Ongeldige tekenklasse naam"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "Niet-overeenkomende `{'"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "Onbekende optie voor `s'"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Ontbrekende opdracht"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Reguliere uitdrukking te groot"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "optie `e' niet ondersteund"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Ongeldige inhoud van \\{\\}"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -362,74 +562,47 @@ msgstr "leesfout op %s: %s"
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: kan %s niet lezen: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Succes"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Succes"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Geen overeenkomst"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Geen overeenkomst"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Ongeldige reguliere uitdrukking"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Ongeldige reguliere uitdrukking"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Ongeldig sorteerteken"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Ongeldig sorteerteken"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Ongeldige tekenklasse naam"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Backslash aan het einde"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Backslash aan het einde"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Ongeldige terugverwijzing"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Ongeldige terugverwijzing"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "Niet-overeenkomende [ of [^"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "Niet-overeenkomende [ of [^"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "Niet-overeenkomende ( of \\("
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "Niet-overeenkomende ( of \\("
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "Niet-overeenkomende \\{"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "Niet-overeenkomende \\{"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Ongeldig bereikeinde"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Ongeldige inhoud van \\{\\}"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Geheugen uitgeput"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Ongeldig bereikeinde"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Ongeldige voorafgaande reguliere uitdrukking"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Geheugen uitgeput"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Vroegtijdig einde van reguliere uitdrukking"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Ongeldige voorafgaande reguliere uitdrukking"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "Niet-overeenkomende ) of \\)"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Vroegtijdig einde van reguliere uitdrukking"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Reguliere uitdrukking te groot"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "Niet-overeenkomende ) of \\)"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Geen eerdere reguliere uitdrukking"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Geen eerdere reguliere uitdrukking"
|
||||
@@ -6,7 +6,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.1.1\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2004-07-08 19:58+0200\n"
|
||||
"Last-Translator: Wojciech Polak <polak@gnu.org>\n"
|
||||
"Language-Team: Polish <translation-team-pl@lists.sourceforge.net>\n"
|
||||
@@ -16,6 +16,206 @@ msgstr ""
|
||||
"Plural-Forms: nplurals=3; plural=(n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 "
|
||||
"|| n%100>=20) ? 1 : 2);\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "nieznana opcja dla polecenia `s'"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "b³±d odczytu w %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Nieprawid³owa nazwa klasy znaku"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "niedopasowany znak `{'"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "nieznana opcja dla polecenia `s'"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "brakuje polecenia"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Wyra¿enie regularne jest zbyt du¿e"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "opcja `e' nie jest wspierana"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Nieprawid³owa zawarto¶æ \\{\\}"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
msgid "multiple `!'s"
|
||||
msgstr "wielokrotny znak `!'"
|
||||
@@ -372,74 +572,47 @@ msgstr "b
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "nie mo¿na zmieniæ nazwy %s: %s"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Sukces"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Sukces"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Brak dopasowania"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Brak dopasowania"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Nieprawid³owe wyra¿enie regularne"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Nieprawid³owe wyra¿enie regularne"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Nieprawid³owy znak porównania"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Nieprawid³owy znak porównania"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Nieprawid³owa nazwa klasy znaku"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Koñcowy znak backslash"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Koñcowy znak backslash"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Nieprawid³owe odwo³anie wsteczne"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Nieprawid³owe odwo³anie wsteczne"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "Niedopasowany znak [ lub [^"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "Niedopasowany znak [ lub [^"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "Niedopasowany znak ( lub \\("
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "Niedopasowany znak ( lub \\("
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "Niedopasowany znak \\{"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "Niedopasowany znak \\{"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Nieprawid³owy koniec zakresu"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Nieprawid³owa zawarto¶æ \\{\\}"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Pamiêæ wyczerpana"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Nieprawid³owy koniec zakresu"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Nieprawid³owe poprzedzaj±ce wyra¿enie regularne"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Pamiêæ wyczerpana"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Przedwczesny koniec wyra¿enia regularnego"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Nieprawid³owe poprzedzaj±ce wyra¿enie regularne"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "Niedopasowany znak ) lub \\)"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Przedwczesny koniec wyra¿enia regularnego"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Wyra¿enie regularne jest zbyt du¿e"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "Niedopasowany znak ) lub \\)"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Brak poprzedniego wyra¿enia regularnego"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Brak poprzedniego wyra¿enia regularnego"
|
||||
+231
-58
@@ -8,7 +8,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.0.1\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2002-11-08 17:44-0300\n"
|
||||
"Last-Translator: Aurélio Marinho Jargas <aurelio@verde666.org>\n"
|
||||
"Language-Team: Brazilian Portuguese <ldp-br@bazar.conectiva.com.br>\n"
|
||||
@@ -18,6 +18,206 @@ msgstr ""
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "Opção desconhecida para o comando `s' (s///?)"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "erro de leitura em %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Nome inválido de classe de caracteres"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "`{' não terminada"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "Opção desconhecida para o comando `s' (s///?)"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Falta especificar um comando ao endereço"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Expressão regular grande demais"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "opção `e' não suportada"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Conteúdo inválido no \\{\\} (permitidos números e vírgula)"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -360,74 +560,47 @@ msgstr "erro de leitura em %s: %s"
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: não foi possível ler %s: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Sucesso"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Sucesso"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Nada encontrado"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Nada encontrado"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Expressão regular inválida"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Expressão regular inválida"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Caractere de ordenação inválido"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Caractere de ordenação inválido"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Nome inválido de classe de caracteres"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Escape \\ no final"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Escape \\ no final"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Retrovisor \\n inválido"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Retrovisor \\n inválido"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "[ ou [^ não terminado"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "[ ou [^ não terminado"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "( ou \\( não terminado"
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "( ou \\( não terminado"
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "\\{ não terminado"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "\\{ não terminado"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Fim de intervalo (range) inválido"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Conteúdo inválido no \\{\\} (permitidos números e vírgula)"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Falta de memória"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Fim de intervalo (range) inválido"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Expressão regular anterior inválida"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Falta de memória"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Fim prematuro da expressão regular"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Expressão regular anterior inválida"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr ") or \\) inesperado"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Fim prematuro da expressão regular"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Expressão regular grande demais"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr ") or \\) inesperado"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Não há expressão regular anterior"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Não há expressão regular anterior"
|
||||
@@ -7,7 +7,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.0.8\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2003-11-22 12:00-0500\n"
|
||||
"Last-Translator: Laurentiu Buzdugan <buzdugan@voyager.net>\n"
|
||||
"Language-Team: Romanian <translation-team-ro@lists.sourceforge.net>\n"
|
||||
@@ -17,6 +17,206 @@ msgstr ""
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "Opþiune necunoscutã pentru `s'"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "eroare citire pentru %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Nume de clasã de caractere incorect"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "`{' fãrã pereche"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "Opþiune necunoscutã pentru `s'"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Comandã absentã"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Expresie regularã prea mare"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "opþiunea `e' nu e suportatã"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Conþinut incorect pentru \\{\\}"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -362,74 +562,47 @@ msgstr "eroare citire pentru %s: %s"
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: nu pot citi %s: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Succes"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Succes"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Nici o potrivire"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Nici o potrivire"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Expresie regularã incorectã"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Expresie regularã incorectã"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Colaþiune de caractere incorectã"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Colaþiune de caractere incorectã"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Nume de clasã de caractere incorect"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Backslash în coadã"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Backslash în coadã"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Referinþã înapoi incorectã"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Referinþã înapoi incorectã"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "[ sau [^ fãrã pereche"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "[ sau [^ fãrã pereche"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "( sau \\( fãrã pereche"
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "( sau \\( fãrã pereche"
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "\\{ fãrã pereche"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "\\{ fãrã pereche"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Sfârºit de interval incorect"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Conþinut incorect pentru \\{\\}"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Memorie epuizatã"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Sfârºit de interval incorect"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Expresie regularã precedentã incorectã"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Memorie epuizatã"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Sfârºit prematur al expresiei regulare"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Expresie regularã precedentã incorectã"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr ") sau \\) fãrã pereche"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Sfârºit prematur al expresiei regulare"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Expresie regularã prea mare"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr ") sau \\) fãrã pereche"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Nici o expresie regularã anterioarã"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Nici o expresie regularã anterioarã"
|
||||
@@ -6,7 +6,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed-4.1.1\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2004-07-07 17:54+0300\n"
|
||||
"Last-Translator: Pavel Maryanov <acid_jack@ukr.net>\n"
|
||||
"Language-Team: Russian <ru@li.org>\n"
|
||||
@@ -16,6 +16,206 @@ msgstr ""
|
||||
"Plural-Forms: nplurals=2; plural=n>1;\n"
|
||||
"X-Generator: KBabel 1.3\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "ÎÅÉÚ×ÅÓÔÎÙÊ ÍÏÄÉÆÉËÁÔÏÒ Ë `s'"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "ÏÛÉÂËÁ ÞÔÅÎÉÑ %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "îÅÄÏÐÕÓÔÉÍÏÅ ÉÍÑ ÄÌÑ ËÌÁÓÓÁ ÓÉÍ×ÏÌÁ"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "ÎÅÐÁÒÎÙÊ ÓÉÍ×ÏÌ `{'"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "ÎÅÉÚ×ÅÓÔÎÙÊ ÍÏÄÉÆÉËÁÔÏÒ Ë `s'"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "ÏÔÓÕÔÓÔ×ÕÅÔ ËÏÍÁÎÄÁ"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "òÅÇÕÌÑÒÎÏÅ ×ÙÒÁÖÅÎÉÅ ÓÌÉÛËÏÍ ÂÏÌØÛÏÅ"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "ÏÐÃÉÑ `e' ÎÅ ÐÏÄÄÅÒÖÉ×ÁÅÔÓÑ"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "îÅÄÏÐÕÓÔÉÍÏÅ ÓÏÄÅÒÖÉÍÏÅ × \\{\\}"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
msgid "multiple `!'s"
|
||||
msgstr "ÎÅÓËÏÌØËÏ ÓÉÍ×ÏÌÏ× `!'"
|
||||
@@ -369,74 +569,47 @@ msgstr "
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "ÎÅ×ÏÚÍÏÖÎÏ ÐÅÒÅÉÍÅÎÏ×ÁÔØ %s: %s"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "õÓÐÅÛÎÏ"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "õÓÐÅÛÎÏ"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "îÅÔ ÓÏÏÔ×ÅÓÔ×ÉÑ"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "îÅÔ ÓÏÏÔ×ÅÓÔ×ÉÑ"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "îÅÄÏÐÕÓÔÉÍÏÅ ÒÅÇÕÌÑÒÎÏÅ ×ÙÒÁÖÅÎÉÅ"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "îÅÄÏÐÕÓÔÉÍÏÅ ÒÅÇÕÌÑÒÎÏÅ ×ÙÒÁÖÅÎÉÅ"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "îÅÄÏÐÕÓÔÉÍÙÊ ÓÉÍ×ÏÌ ÓÒÁ×ÎÅÎÉÑ"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "îÅÄÏÐÕÓÔÉÍÙÊ ÓÉÍ×ÏÌ ÓÒÁ×ÎÅÎÉÑ"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "îÅÄÏÐÕÓÔÉÍÏÅ ÉÍÑ ÄÌÑ ËÌÁÓÓÁ ÓÉÍ×ÏÌÁ"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "úÁ×ÅÒÛÁÀÝÁÑ ÏÂÒÁÔÎÁÑ ËÏÓÁÑ ÞÅÒÔÁ"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "úÁ×ÅÒÛÁÀÝÁÑ ÏÂÒÁÔÎÁÑ ËÏÓÁÑ ÞÅÒÔÁ"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "îÅÄÏÐÕÓÔÉÍÁÑ ÏÂÒÁÔÎÁÑ ÓÓÙÌËÁ"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "îÅÄÏÐÕÓÔÉÍÁÑ ÏÂÒÁÔÎÁÑ ÓÓÙÌËÁ"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "îÅÐÁÒÎÙÊ ÓÉÍ×ÏÌ [ ÉÌÉ [^"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "îÅÐÁÒÎÙÊ ÓÉÍ×ÏÌ [ ÉÌÉ [^"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "îÅÐÁÒÎÙÊ ÓÉÍ×ÏÌ ( or \\("
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "îÅÐÁÒÎÙÊ ÓÉÍ×ÏÌ ( or \\("
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "îÅÐÁÒÎÙÊ ÓÉÍ×ÏÌ \\{"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "îÅÐÁÒÎÙÊ ÓÉÍ×ÏÌ \\{"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "îÅÄÏÐÕÓÔÉÍÏÅ ÏËÏÎÞÁÎÉÅ ÄÉÁÐÁÚÏÎÁ"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "îÅÄÏÐÕÓÔÉÍÏÅ ÓÏÄÅÒÖÉÍÏÅ × \\{\\}"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "ðÁÍÑÔØ ÉÓÞÅÒÐÁÎÁ"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "îÅÄÏÐÕÓÔÉÍÏÅ ÏËÏÎÞÁÎÉÅ ÄÉÁÐÁÚÏÎÁ"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "îÅÄÏÐÕÓÔÉÍÏÅ ÐÒÅÄÛÅÓÔ×ÕÀÝÅÅ ÒÅÇÕÌÑÒÎÏÅ ×ÙÒÁÖÅÎÉÅ"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "ðÁÍÑÔØ ÉÓÞÅÒÐÁÎÁ"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "ðÒÅÖÄÅ×ÒÅÍÅÎÎÏÅ ÏËÏÎÞÁÎÉÅ ÒÅÇÕÌÑÒÎÏÇÏ ×ÙÒÁÖÅÎÉÑ"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "îÅÄÏÐÕÓÔÉÍÏÅ ÐÒÅÄÛÅÓÔ×ÕÀÝÅÅ ÒÅÇÕÌÑÒÎÏÅ ×ÙÒÁÖÅÎÉÅ"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "îÅÐÁÒÎÙÊ ÓÉÍ×ÏÌ ) ÉÌÉ \\)"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "ðÒÅÖÄÅ×ÒÅÍÅÎÎÏÅ ÏËÏÎÞÁÎÉÅ ÒÅÇÕÌÑÒÎÏÇÏ ×ÙÒÁÖÅÎÉÑ"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "òÅÇÕÌÑÒÎÏÅ ×ÙÒÁÖÅÎÉÅ ÓÌÉÛËÏÍ ÂÏÌØÛÏÅ"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "îÅÐÁÒÎÙÊ ÓÉÍ×ÏÌ ) ÉÌÉ \\)"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "îÅÔ ÐÒÅÄÙÄÕÝÅÇÏ ÒÅÇÕÌÑÒÎÏÇÏ ×ÙÒÁÖÅÎÉÑ"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "îÅÔ ÐÒÅÄÙÄÕÝÅÇÏ ÒÅÇÕÌÑÒÎÏÇÏ ×ÙÒÁÖÅÎÉÑ"
|
||||
@@ -6,7 +6,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: GNU sed 4.0.8\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2003-10-25 17:22+0200\n"
|
||||
"Last-Translator: Marcel Telka <marcel@telka.sk>\n"
|
||||
"Language-Team: Slovak <sk-i18n@lists.linux.sk>\n"
|
||||
@@ -16,6 +16,206 @@ msgstr ""
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"Plural-Forms: nplurals=3; plural= (n==1) ? 1 : (n>=2 && n<=4) ? 2 : 0;\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "Neznáma voľba pre `s'"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "chyba pri čítaní z %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Neplatný názov triedy znakov"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "Nezodpovedajúca `{'"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "Neznáma voľba pre `s'"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Chýbajúci príkaz"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Regulárny výraz je príliš veľký"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "voľba `e' nie je podporovaná"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Neplatný obsah \\{\\}"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -362,74 +562,47 @@ msgstr "chyba pri čítaní z %s: %s"
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: %s nie je možné čítať: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Úspech"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Úspech"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Nezodpovedá"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Nezodpovedá"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Neplatný regulárny výraz"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Neplatný regulárny výraz"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Neplatný znak pre porovnávanie"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Neplatný znak pre porovnávanie"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Neplatný názov triedy znakov"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Ukončovacie opačné lomítko"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Ukončovacie opačné lomítko"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Neplatný spätný odkaz"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Neplatný spätný odkaz"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "Nezodpovedajúca [ alebo [^"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "Nezodpovedajúca [ alebo [^"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "Nezodpovedajúca ( alebo \\("
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "Nezodpovedajúca ( alebo \\("
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "Nezodpovedajúca \\{"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "Nezodpovedajúca \\{"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Neplatný koniec rozsahu"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Neplatný obsah \\{\\}"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Vyčerpaná pamäť"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Neplatný koniec rozsahu"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Neplatný predchádzajúci regulárny výraz"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Vyčerpaná pamäť"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Neočakávaný koniec regulárneho výrazu"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Neplatný predchádzajúci regulárny výraz"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "Nezodpovedajúca ) alebo \\)"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Neočakávaný koniec regulárneho výrazu"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Regulárny výraz je príliš veľký"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "Nezodpovedajúca ) alebo \\)"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Bez predchádzajúceho regulárneho výrazu"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Bez predchádzajúceho regulárneho výrazu"
|
||||
@@ -6,7 +6,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.0.6\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2003-04-02 17:20+0200\n"
|
||||
"Last-Translator: Primo¾ Peterlin <primoz.peterlin@biofiz.mf.uni-lj.si>\n"
|
||||
"Language-Team: Slovenian <translation-team-sl@lists.sourceforge.net>\n"
|
||||
@@ -17,6 +17,206 @@ msgstr ""
|
||||
"Plural-Forms: nplurals=4; plural=(n%100==1 ? 1 : n%100==2 ? 2 : n%100==3 || n"
|
||||
"%100==4 ? 3 : 0);\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "Neznane izbire pri ukazu \"s\""
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "napaka pri branju z %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Neveljavno ime razreda znakov"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "Oklepaj { brez zaklepaja"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "Neznane izbire pri ukazu \"s\""
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Ukaz manjka"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Regularni izraz prevelik"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "Izbira ,e` ni podprta"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Neveljavna vsebina \\{\\}"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -362,74 +562,47 @@ msgstr "napaka pri branju z %s: %s"
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: %s ni mo¾no prebrati: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Uspe¹no"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Uspe¹no"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Ni ujemanja"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Ni ujemanja"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Neveljavni regularni izraz"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Neveljavni regularni izraz"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Znaka izven abecede"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Znaka izven abecede"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Neveljavno ime razreda znakov"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Zakljuèna obrnjena po¹evnica"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Zakljuèna obrnjena po¹evnica"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Neveljavni povratni sklic"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Neveljavni povratni sklic"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "Oklepaj [ ali [^ brez zaklepaja"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "Oklepaj [ ali [^ brez zaklepaja"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "Oklepaj ( ali \\( brez zaklepaja"
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "Oklepaj ( ali \\( brez zaklepaja"
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "Oklepaj \\{ brez zaklepaja"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "Oklepaj \\{ brez zaklepaja"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Neveljavna zgornja meja intervala"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Neveljavna vsebina \\{\\}"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Zmanjkalo pomnilnika"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Neveljavna zgornja meja intervala"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Neveljaven prej¹nji regularni izraz"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Zmanjkalo pomnilnika"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Predèasni zakljuèek regularnega izraza"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Neveljaven prej¹nji regularni izraz"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "Oklepaj ) ali \\) brez zaklepaja"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Predèasni zakljuèek regularnega izraza"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Regularni izraz prevelik"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "Oklepaj ) ali \\) brez zaklepaja"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Prej¹nji regularni izraz manjka"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Prej¹nji regularni izraz manjka"
|
||||
@@ -5,7 +5,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.0.9\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2004-01-13 22:51-0500\n"
|
||||
"Last-Translator: Aleksandar Jelenak <jelenak@netlinkplus.net>\n"
|
||||
"Language-Team: Serbian <sr@li.org>\n"
|
||||
@@ -16,6 +16,206 @@ msgstr ""
|
||||
"Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : (n%10>=2 && n"
|
||||
"%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "Непозната опција за „s“"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "грешка учитавања на %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Неисправно име класе знакова"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "Неспарена „{“"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "Непозната опција за „s“"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Недостаје наредба"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Регуларни израз сувише велик"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "опција „e“ није подржана"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Неисправни садржај у \\{\\}"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -359,74 +559,47 @@ msgstr "грешка учитавања на %s: %s"
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: не може читати %s: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Успех"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Успех"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Без поклапања"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Без поклапања"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Неисправни регуларни израз"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Неисправни регуларни израз"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Неисправни знак прикупљања"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Неисправни знак прикупљања"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Неисправно име класе знакова"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Пратећа обрнута коса црта"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Пратећа обрнута коса црта"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Неисправна повратна референца"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Неисправна повратна референца"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "Неспарено [ или ^["
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "Неспарено [ или ^["
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "Неспарено ( или \\("
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "Неспарено ( или \\("
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "Неспарено \\{"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "Неспарено \\{"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Неисправни крај опсега"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Неисправни садржај у \\{\\}"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Меморија исцрпљена"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Неисправни крај опсега"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Неисправан претходећи регуларни израз"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Меморија исцрпљена"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Преран крај регуларног израза"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Неисправан претходећи регуларни израз"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "Неспарено ) или \\)"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Преран крај регуларног израза"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Регуларни израз сувише велик"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "Неспарено ) или \\)"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Без претходног регуларног израза"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Без претходног регуларног израза"
|
||||
+194
-73
@@ -7,7 +7,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: PACKAGE VERSION\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
|
||||
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
||||
"Language-Team: LANGUAGE <LL@li.org>\n"
|
||||
@@ -16,6 +16,199 @@ msgstr ""
|
||||
"Content-Transfer-Encoding: 8bit\n"
|
||||
"Plural-Forms: nplurals=INTEGER; plural=EXPRESSION;\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
msgid "unmatched braces"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
msgid "missing ) after comment"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
msgid "regular expression too large"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
msgid "multiple `!'s"
|
||||
msgstr ""
|
||||
@@ -326,75 +519,3 @@ msgstr ""
|
||||
#, c-format
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr ""
|
||||
@@ -5,7 +5,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.1.1\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2004-07-11 11:45+0200\n"
|
||||
"Last-Translator: Christian Rose <menthos@menthos.com>\n"
|
||||
"Language-Team: Swedish <sv@li.org>\n"
|
||||
@@ -14,6 +14,206 @@ msgstr ""
|
||||
"Content-Transfer-Encoding: 8bit\n"
|
||||
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "flaggan okänd för \"s\""
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "läsfel vid %s: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Ogiltigt teckenklassnamn"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "obalanserad \"{\""
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "flaggan okänd för \"s\""
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "kommando saknas"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Reguljärt uttryck för stort"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr "flaggan \"e\" stöds inte"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "Ogiltigt innehåll i \\{\\}"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
msgid "multiple `!'s"
|
||||
msgstr "flera \"!\""
|
||||
@@ -373,74 +573,47 @@ msgstr "l
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "kan inte byta namn på %s: %s"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Lyckades"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Lyckades"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Ingen träff"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Ingen träff"
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Ogiltigt reguljärt uttryck"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Ogiltigt reguljärt uttryck"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Ogiltigt sorteringstecken"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Ogiltigt sorteringstecken"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Ogiltigt teckenklassnamn"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Eftersläpande omvänt snedstreck"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Eftersläpande omvänt snedstreck"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Ogiltig bakåtreferens"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Ogiltig bakåtreferens"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "Obalanserad [ eller [^"
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "Obalanserad [ eller [^"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "Obalanserad ( eller \\("
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "Obalanserad ( eller \\("
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "Obalanserad \\{"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "Obalanserad \\{"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Ogiltigt intervallslut"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "Ogiltigt innehåll i \\{\\}"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Minnet slut"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Ogiltigt intervallslut"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Ogiltigt föregående reguljärt uttryck"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Minnet slut"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "För tidigt slut på reguljärt uttryck"
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Ogiltigt föregående reguljärt uttryck"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "Obalanserad ) eller \\)"
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "För tidigt slut på reguljärt uttryck"
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Reguljärt uttryck för stort"
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "Obalanserad ) eller \\)"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Inget tidigare reguljärt uttryck"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Inget tidigare reguljärt uttryck"
|
||||
@@ -5,7 +5,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 4.0.9\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2004-05-19 18:06+0300\n"
|
||||
"Last-Translator: Deniz Akkus Kanca <deniz@arayan.com>\n"
|
||||
"Language-Team: Turkish <gnu-tr-u12a@lists.sourceforge.net>\n"
|
||||
@@ -15,6 +15,207 @@ msgstr ""
|
||||
"X-Generator: KBabel 1.0.2\n"
|
||||
"Plural-Forms: nplurals=1; plural=0;\n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "`s' komutuna bilinmeyen seçenek verilmiş"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "%s'de okuma hatası: %s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
#, fuzzy
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr "Hatalı karakter sınıf ismi"
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "Eşleşmeyen '{'"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "`s' komutuna bilinmeyen seçenek verilmiş"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "Komut eksik"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
#, fuzzy
|
||||
msgid "regular expression too large"
|
||||
msgstr "Düzenli ifade fazla büyük"
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
#, fuzzy
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr " e' seçeneği desteklenmiyor"
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
#, fuzzy
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr "\\{\\} içeriği hatalı"
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -358,82 +559,54 @@ msgstr "%s'de okuma hatası: %s"
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s: %s okunamıyor: %s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr "Başarılı"
|
||||
#~ msgid "Success"
|
||||
#~ msgstr "Başarılı"
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr "Eşleşme bulunamadı"
|
||||
#~ msgid "No match"
|
||||
#~ msgstr "Eşleşme bulunamadı"
|
||||
|
||||
#
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr "Hatalı düzenli ifade"
|
||||
#~ msgid "Invalid regular expression"
|
||||
#~ msgstr "Hatalı düzenli ifade"
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr "Hatalı birleştirme karakteri"
|
||||
#~ msgid "Invalid collation character"
|
||||
#~ msgstr "Hatalı birleştirme karakteri"
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr "Hatalı karakter sınıf ismi"
|
||||
#~ msgid "Trailing backslash"
|
||||
#~ msgstr "Sonda fazla gerikesme var"
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr "Sonda fazla gerikesme var"
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr "Hatalı geri referans"
|
||||
#~ msgid "Invalid back reference"
|
||||
#~ msgstr "Hatalı geri referans"
|
||||
|
||||
#
|
||||
#: lib/regcomp.c:171
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "Eşleşmeyen [ veya [^"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "Eşleşmeyen [ veya [^"
|
||||
|
||||
#
|
||||
#: lib/regcomp.c:174
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "Eşleşmeyen ( veya \\("
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "Eşleşmeyen ( veya \\("
|
||||
|
||||
#
|
||||
#: lib/regcomp.c:177
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "Eşleşmeyen \\{"
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "Eşleşmeyen \\{"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr "\\{\\} içeriği hatalı"
|
||||
#~ msgid "Invalid range end"
|
||||
#~ msgstr "Geçersiz kapsam sonu"
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr "Geçersiz kapsam sonu"
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr "Bellek tükendi"
|
||||
#~ msgid "Memory exhausted"
|
||||
#~ msgstr "Bellek tükendi"
|
||||
|
||||
#
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr "Bir önceki düzenli ifade hatalı"
|
||||
#~ msgid "Invalid preceding regular expression"
|
||||
#~ msgstr "Bir önceki düzenli ifade hatalı"
|
||||
|
||||
#
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr "Düzenli ifade erken sonlandı"
|
||||
#~ msgid "Premature end of regular expression"
|
||||
#~ msgstr "Düzenli ifade erken sonlandı"
|
||||
|
||||
#
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr "Düzenli ifade fazla büyük"
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "Eşleşmeyen ) or \\)"
|
||||
|
||||
#
|
||||
#: lib/regcomp.c:198
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "Eşleşmeyen ) or \\)"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr "Daha önce düzenli ifade yok"
|
||||
#~ msgid "No previous regular expression"
|
||||
#~ msgstr "Daha önce düzenli ifade yok"
|
||||
+205
-69
@@ -5,7 +5,7 @@
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: sed 3.02.80\n"
|
||||
"POT-Creation-Date: 2004-08-21 20:46+0200\n"
|
||||
"POT-Creation-Date: 2004-07-13 20:07+0200\n"
|
||||
"PO-Revision-Date: 2002-08-18 11:11+0800\n"
|
||||
"Last-Translator: Wang Li <charles@linux.net.cn>\n"
|
||||
"Language-Team: Chinese (simplified) <i18n-translation@lists.linux.net.cn>\n"
|
||||
@@ -14,6 +14,202 @@ msgstr ""
|
||||
"Content-Transfer-Encoding: 8bit\n"
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
|
||||
#: pcre/pcregrep.c:130
|
||||
msgid "Usage: pcregrep [-bepchilnsvx] pattern [file] ...\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:212
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: unknown option %c\n"
|
||||
msgstr "“s”的未知选项"
|
||||
|
||||
#: pcre/pcregrep.c:239
|
||||
#, c-format
|
||||
msgid "pcregrep: error in regex at offset %d: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:248
|
||||
#, c-format
|
||||
msgid "pcregrep: error while studing regex: %s\n"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/pcregrep.c:268
|
||||
#, fuzzy, c-format
|
||||
msgid "pcregrep: failed to open %s: %s\n"
|
||||
msgstr "读取 %s 出错:%s"
|
||||
|
||||
#: pcre/regexp.c:48
|
||||
msgid "\\ at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:49
|
||||
msgid "\\c at end of pattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:50
|
||||
msgid "unrecognized character follows \\"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:51
|
||||
msgid "numbers out of order in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:52
|
||||
msgid "number too big in {} quantifier"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:53 pcre/regexp.c:130
|
||||
msgid "missing terminating ] for character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:54
|
||||
msgid "invalid escape sequence in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:55 pcre/regexp.c:136
|
||||
msgid "range out of order in character class"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:56 pcre/regexp.c:128
|
||||
msgid "nothing to repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:57
|
||||
msgid "operand of unlimited repeat could match the empty string"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:58
|
||||
msgid "internal error: unexpected repeat"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:59
|
||||
msgid "unrecognized character after (?"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:60
|
||||
msgid "unused error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:61 pcre/regexp.c:129
|
||||
#, fuzzy
|
||||
msgid "unmatched braces"
|
||||
msgstr "未匹配的“{”"
|
||||
|
||||
#: pcre/regexp.c:62 pcre/regexp.c:139
|
||||
msgid "back reference to non-existent subpattern"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:63
|
||||
msgid "erroffset passed as NULL"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:64
|
||||
#, fuzzy
|
||||
msgid "unknown option bit(s) set"
|
||||
msgstr "“s”的未知选项"
|
||||
|
||||
#: pcre/regexp.c:65
|
||||
#, fuzzy
|
||||
msgid "missing ) after comment"
|
||||
msgstr "遗漏命令"
|
||||
|
||||
#: pcre/regexp.c:66
|
||||
msgid "parentheses nested too deeply"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:67 pcre/regexp.c:137
|
||||
msgid "regular expression too large"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:68 pcre/regexp.c:138
|
||||
msgid "failed to get memory"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:69 pcre/regexp.c:135
|
||||
msgid "unmatched parentheses"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:70
|
||||
msgid "internal error: code overflow"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:71
|
||||
msgid "unrecognized character after (?<"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:72
|
||||
msgid "lookbehind assertion is not fixed length"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:73
|
||||
msgid "malformed number after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:74
|
||||
msgid "conditional group contains more than two branches"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:75
|
||||
msgid "assertion expected after (?("
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:76
|
||||
msgid "(?p must be followed by )"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:77 pcre/regexp.c:132
|
||||
msgid "unknown POSIX class name"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:78
|
||||
msgid "POSIX collating elements are not supported"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:79
|
||||
msgid "bad condition (?(0)"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:125
|
||||
msgid "internal error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:126
|
||||
msgid "invalid repeat counts in {}"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:127
|
||||
msgid "pattern error"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:131
|
||||
msgid "bad collating element"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:133
|
||||
msgid "bad escape sequence"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:134
|
||||
msgid "empty expression"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:140
|
||||
msgid "bad argument"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:141
|
||||
msgid "match failed"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:182
|
||||
msgid "unknown error code"
|
||||
msgstr ""
|
||||
|
||||
#: pcre/regexp.c:184
|
||||
#, c-format
|
||||
msgid "%s at offset %-6d"
|
||||
msgstr ""
|
||||
|
||||
#: sed/compile.c:162
|
||||
#, fuzzy
|
||||
msgid "multiple `!'s"
|
||||
@@ -342,78 +538,18 @@ msgstr "
|
||||
msgid "cannot rename %s: %s"
|
||||
msgstr "%s:无法读取 %s:%s\n"
|
||||
|
||||
#: lib/regcomp.c:150
|
||||
msgid "Success"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:153
|
||||
msgid "No match"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:156
|
||||
msgid "Invalid regular expression"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:159
|
||||
msgid "Invalid collation character"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:162
|
||||
msgid "Invalid character class name"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:165
|
||||
msgid "Trailing backslash"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:168
|
||||
msgid "Invalid back reference"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:171
|
||||
#, fuzzy
|
||||
msgid "Unmatched [ or [^"
|
||||
msgstr "未匹配的“{”"
|
||||
#~ msgid "Unmatched [ or [^"
|
||||
#~ msgstr "未匹配的“{”"
|
||||
|
||||
#: lib/regcomp.c:174
|
||||
#, fuzzy
|
||||
msgid "Unmatched ( or \\("
|
||||
msgstr "未匹配的“{”"
|
||||
#~ msgid "Unmatched ( or \\("
|
||||
#~ msgstr "未匹配的“{”"
|
||||
|
||||
#: lib/regcomp.c:177
|
||||
#, fuzzy
|
||||
msgid "Unmatched \\{"
|
||||
msgstr "未匹配的“{”"
|
||||
#~ msgid "Unmatched \\{"
|
||||
#~ msgstr "未匹配的“{”"
|
||||
|
||||
#: lib/regcomp.c:180
|
||||
msgid "Invalid content of \\{\\}"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:183
|
||||
msgid "Invalid range end"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:186
|
||||
msgid "Memory exhausted"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:189
|
||||
msgid "Invalid preceding regular expression"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:192
|
||||
msgid "Premature end of regular expression"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:195
|
||||
msgid "Regular expression too big"
|
||||
msgstr ""
|
||||
|
||||
#: lib/regcomp.c:198
|
||||
#, fuzzy
|
||||
msgid "Unmatched ) or \\)"
|
||||
msgstr "未匹配的“{”"
|
||||
|
||||
#: lib/regcomp.c:672
|
||||
msgid "No previous regular expression"
|
||||
msgstr ""
|
||||
#~ msgid "Unmatched ) or \\)"
|
||||
#~ msgstr "未匹配的“{”"
|
||||
+3
-3
@@ -6,12 +6,12 @@ localedir = $(datadir)/locale
|
||||
sed_SOURCES = sed.c compile.c execute.c regexp.c fmt.c mbcs.c
|
||||
noinst_HEADERS = sed.h
|
||||
|
||||
AM_CPPFLAGS = -I$(top_srcdir)/lib -I$(top_srcdir)/intl \
|
||||
AM_CPPFLAGS = -I$(top_srcdir)/lib -I$(top_srcdir)/intl -I$(top_srcdir)/pcre \
|
||||
-I$(top_srcdir) -I$(top_builddir)/lib \
|
||||
-DLOCALEDIR=\"$(localedir)\"
|
||||
|
||||
sed_LDADD = ../lib/libsed.a @INTLLIBS@
|
||||
sed_DEPENDENCIES = ../lib/libsed.a
|
||||
sed_LDADD = ../pcre/libpcre.a ../lib/libsed.a @INTLLIBS@
|
||||
sed_DEPENDENCIES = ../pcre/libpcre.a ../lib/libsed.a
|
||||
|
||||
$(PROGRAMS): $(LDADD)
|
||||
|
||||
|
||||
@@ -21,7 +21,7 @@
|
||||
#endif
|
||||
|
||||
#include "basicdefs.h"
|
||||
#include "regex.h"
|
||||
#include "regexp.h"
|
||||
|
||||
#ifndef BOOTSTRAP
|
||||
#include <stdio.h>
|
||||
@@ -250,5 +250,4 @@ extern int mb_cur_max;
|
||||
#endif
|
||||
|
||||
extern int brlen P_ ((int ch, mbstate_t *ps));
|
||||
extern void initialize_mbcs P_ ((void));
|
||||
|
||||
@@ -1,829 +0,0 @@
|
||||
;
|
||||
;
|
||||
; this file contains a script of tests to run through regress.exe
|
||||
;
|
||||
; comments start with a semicolon and proceed to the end of the line
|
||||
;
|
||||
; changes to regular expression compile flags start with a "-" as the first
|
||||
; non-whitespace character and consist of a list of the printable names
|
||||
; of the flags, for example "match_default"
|
||||
;
|
||||
; Other lines contain a test to perform using the current flag status
|
||||
; the first token contains the expression to compile, the second the string
|
||||
; to match it against. If the second string is "!" then the expression should
|
||||
; not compile, that is the first string is an invalid regular expression.
|
||||
; This is then followed by a list of integers that specify what should match,
|
||||
; each pair represents the starting and ending positions of a subexpression
|
||||
; starting with the zeroth subexpression (the whole match).
|
||||
; A value of -1 indicates that the subexpression should not take part in the
|
||||
; match at all, if the first value is -1 then no part of the expression should
|
||||
; match the string.
|
||||
;
|
||||
; Tests taken from BOOST testsuite and adapted to glibc regex.
|
||||
;
|
||||
; Boost Software License - Version 1.0 - August 17th, 2003
|
||||
;
|
||||
; Permission is hereby granted, free of charge, to any person or organization
|
||||
; obtaining a copy of the software and accompanying documentation covered by
|
||||
; this license (the "Software") to use, reproduce, display, distribute,
|
||||
; execute, and transmit the Software, and to prepare derivative works of the
|
||||
; Software, and to permit third-parties to whom the Software is furnished to
|
||||
; do so, all subject to the following:
|
||||
;
|
||||
; The copyright notices in the Software and this entire statement, including
|
||||
; the above license grant, this restriction and the following disclaimer,
|
||||
; must be included in all copies of the Software, in whole or in part, and
|
||||
; all derivative works of the Software, unless such copies or derivative
|
||||
; works are solely in the form of machine-executable object code generated by
|
||||
; a source language processor.
|
||||
;
|
||||
; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
; FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
|
||||
; SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
|
||||
; FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
|
||||
; ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
; DEALINGS IN THE SOFTWARE.
|
||||
;
|
||||
|
||||
- match_default normal REG_EXTENDED
|
||||
|
||||
;
|
||||
; try some really simple literals:
|
||||
a a 0 1
|
||||
Z Z 0 1
|
||||
Z aaa -1 -1
|
||||
Z xxxxZZxxx 4 5
|
||||
|
||||
; and some simple brackets:
|
||||
(a) zzzaazz 3 4 3 4
|
||||
() zzz 0 0 0 0
|
||||
() "" 0 0 0 0
|
||||
( !
|
||||
) ) 0 1
|
||||
(aa !
|
||||
aa) baa)b 1 4
|
||||
a b -1 -1
|
||||
\(\) () 0 2
|
||||
\(a\) (a) 0 3
|
||||
\() () 0 2
|
||||
(\) !
|
||||
p(a)rameter ABCparameterXYZ 3 12 4 5
|
||||
[pq](a)rameter ABCparameterXYZ 3 12 4 5
|
||||
|
||||
; now try escaped brackets:
|
||||
- match_default bk_parens REG_BASIC
|
||||
\(a\) zzzaazz 3 4 3 4
|
||||
\(\) zzz 0 0 0 0
|
||||
\(\) "" 0 0 0 0
|
||||
\( !
|
||||
\) !
|
||||
\(aa !
|
||||
aa\) !
|
||||
() () 0 2
|
||||
(a) (a) 0 3
|
||||
(\) !
|
||||
\() !
|
||||
|
||||
; now move on to "." wildcards
|
||||
- match_default normal REG_EXTENDED REG_STARTEND
|
||||
. a 0 1
|
||||
. \n 0 1
|
||||
. \r 0 1
|
||||
. \0 0 1
|
||||
|
||||
;
|
||||
; now move on to the repetion ops,
|
||||
; starting with operator *
|
||||
- match_default normal REG_EXTENDED
|
||||
a* b 0 0
|
||||
ab* a 0 1
|
||||
ab* ab 0 2
|
||||
ab* sssabbbbbbsss 3 10
|
||||
ab*c* a 0 1
|
||||
ab*c* abbb 0 4
|
||||
ab*c* accc 0 4
|
||||
ab*c* abbcc 0 5
|
||||
*a !
|
||||
\<* !
|
||||
\>* !
|
||||
\n* \n\n 0 2
|
||||
\** ** 0 2
|
||||
\* * 0 1
|
||||
|
||||
; now try operator +
|
||||
ab+ a -1 -1
|
||||
ab+ ab 0 2
|
||||
ab+ sssabbbbbbsss 3 10
|
||||
ab+c+ a -1 -1
|
||||
ab+c+ abbb -1 -1
|
||||
ab+c+ accc -1 -1
|
||||
ab+c+ abbcc 0 5
|
||||
+a !
|
||||
\<+ !
|
||||
\>+ !
|
||||
\n+ \n\n 0 2
|
||||
\+ + 0 1
|
||||
\+ ++ 0 1
|
||||
\++ ++ 0 2
|
||||
|
||||
; now try operator ?
|
||||
- match_default normal REG_EXTENDED
|
||||
a? b 0 0
|
||||
ab? a 0 1
|
||||
ab? ab 0 2
|
||||
ab? sssabbbbbbsss 3 5
|
||||
ab?c? a 0 1
|
||||
ab?c? abbb 0 2
|
||||
ab?c? accc 0 2
|
||||
ab?c? abcc 0 3
|
||||
?a !
|
||||
\<? !
|
||||
\>? !
|
||||
\n? \n\n 0 1
|
||||
\? ? 0 1
|
||||
\? ?? 0 1
|
||||
\?? ?? 0 1
|
||||
|
||||
; now try operator {}
|
||||
- match_default normal REG_EXTENDED
|
||||
a{2} a -1 -1
|
||||
a{2} aa 0 2
|
||||
a{2} aaa 0 2
|
||||
a{2,} a -1 -1
|
||||
a{2,} aa 0 2
|
||||
a{2,} aaaaa 0 5
|
||||
a{2,4} a -1 -1
|
||||
a{2,4} aa 0 2
|
||||
a{2,4} aaa 0 3
|
||||
a{2,4} aaaa 0 4
|
||||
a{2,4} aaaaa 0 4
|
||||
a{} !
|
||||
a{2 !
|
||||
a} a} 0 2
|
||||
\{\} {} 0 2
|
||||
|
||||
- match_default normal REG_BASIC
|
||||
a\{2\} a -1 -1
|
||||
a\{2\} aa 0 2
|
||||
a\{2\} aaa 0 2
|
||||
a\{2,\} a -1 -1
|
||||
a\{2,\} aa 0 2
|
||||
a\{2,\} aaaaa 0 5
|
||||
a\{2,4\} a -1 -1
|
||||
a\{2,4\} aa 0 2
|
||||
a\{2,4\} aaa 0 3
|
||||
a\{2,4\} aaaa 0 4
|
||||
a\{2,4\} aaaaa 0 4
|
||||
{} {} 0 2
|
||||
|
||||
; now test the alternation operator |
|
||||
- match_default normal REG_EXTENDED
|
||||
a|b a 0 1
|
||||
a|b b 0 1
|
||||
a(b|c) ab 0 2 1 2
|
||||
a(b|c) ac 0 2 1 2
|
||||
a(b|c) ad -1 -1 -1 -1
|
||||
a\| a| 0 2
|
||||
|
||||
; now test the set operator []
|
||||
- match_default normal REG_EXTENDED
|
||||
; try some literals first
|
||||
[abc] a 0 1
|
||||
[abc] b 0 1
|
||||
[abc] c 0 1
|
||||
[abc] d -1 -1
|
||||
[^bcd] a 0 1
|
||||
[^bcd] b -1 -1
|
||||
[^bcd] d -1 -1
|
||||
[^bcd] e 0 1
|
||||
a[b]c abc 0 3
|
||||
a[ab]c abc 0 3
|
||||
a[^ab]c adc 0 3
|
||||
a[]b]c a]c 0 3
|
||||
a[[b]c a[c 0 3
|
||||
a[-b]c a-c 0 3
|
||||
a[^]b]c adc 0 3
|
||||
a[^-b]c adc 0 3
|
||||
a[b-]c a-c 0 3
|
||||
a[b !
|
||||
a[] !
|
||||
|
||||
; then some ranges
|
||||
[b-e] a -1 -1
|
||||
[b-e] b 0 1
|
||||
[b-e] e 0 1
|
||||
[b-e] f -1 -1
|
||||
[^b-e] a 0 1
|
||||
[^b-e] b -1 -1
|
||||
[^b-e] e -1 -1
|
||||
[^b-e] f 0 1
|
||||
a[1-3]c a2c 0 3
|
||||
a[3-1]c !
|
||||
a[1-3-5]c !
|
||||
a[1- !
|
||||
|
||||
; and some classes
|
||||
a[[:alpha:]]c abc 0 3
|
||||
a[[:unknown:]]c !
|
||||
a[[: !
|
||||
a[[:alpha !
|
||||
a[[:alpha:] !
|
||||
a[[:alpha,:] !
|
||||
a[[:]:]]b !
|
||||
a[[:-:]]b !
|
||||
a[[:alph:]] !
|
||||
a[[:alphabet:]] !
|
||||
[[:alnum:]]+ -%@a0X_- 3 6
|
||||
[[:alpha:]]+ -%@aX_0- 3 5
|
||||
[[:blank:]]+ "a \tb" 1 4
|
||||
[[:cntrl:]]+ a\n\tb 1 3
|
||||
[[:digit:]]+ a019b 1 4
|
||||
[[:graph:]]+ " a%b " 1 4
|
||||
[[:lower:]]+ AabC 1 3
|
||||
; This test fails with STLPort, disable for now as this is a corner case anyway...
|
||||
;[[:print:]]+ "\na b\n" 1 4
|
||||
[[:punct:]]+ " %-&\t" 1 4
|
||||
[[:space:]]+ "a \n\t\rb" 1 5
|
||||
[[:upper:]]+ aBCd 1 3
|
||||
[[:xdigit:]]+ p0f3Cx 1 5
|
||||
|
||||
; now test flag settings:
|
||||
- escape_in_lists REG_NO_POSIX_TEST
|
||||
[\n] \n 0 1
|
||||
- REG_NO_POSIX_TEST
|
||||
|
||||
; line anchors
|
||||
- match_default normal REG_EXTENDED
|
||||
^ab ab 0 2
|
||||
^ab xxabxx -1 -1
|
||||
ab$ ab 0 2
|
||||
ab$ abxx -1 -1
|
||||
- match_default match_not_bol match_not_eol normal REG_EXTENDED REG_NOTBOL REG_NOTEOL
|
||||
^ab ab -1 -1
|
||||
^ab xxabxx -1 -1
|
||||
ab$ ab -1 -1
|
||||
ab$ abxx -1 -1
|
||||
|
||||
; back references
|
||||
- match_default normal REG_PERL
|
||||
a(b)\2c !
|
||||
a(b\1)c !
|
||||
a(b*)c\1d abbcbbd 0 7 1 3
|
||||
a(b*)c\1d abbcbd -1 -1
|
||||
a(b*)c\1d abbcbbbd -1 -1
|
||||
^(.)\1 abc -1 -1
|
||||
a([bc])\1d abcdabbd 4 8 5 6
|
||||
; strictly speaking this is at best ambiguous, at worst wrong, this is what most
|
||||
; re implimentations will match though.
|
||||
a(([bc])\2)*d abbccd 0 6 3 5 3 4
|
||||
|
||||
a(([bc])\2)*d abbcbd -1 -1
|
||||
a((b)*\2)*d abbbd 0 5 1 4 2 3
|
||||
; perl only:
|
||||
(ab*)[ab]*\1 ababaaa 0 7 0 1
|
||||
(a)\1bcd aabcd 0 5 0 1
|
||||
(a)\1bc*d aabcd 0 5 0 1
|
||||
(a)\1bc*d aabd 0 4 0 1
|
||||
(a)\1bc*d aabcccd 0 7 0 1
|
||||
(a)\1bc*[ce]d aabcccd 0 7 0 1
|
||||
^(a)\1b(c)*cd$ aabcccd 0 7 0 1 4 5
|
||||
|
||||
; posix only:
|
||||
- match_default extended REG_EXTENDED
|
||||
(ab*)[ab]*\1 ababaaa 0 7 0 1
|
||||
|
||||
;
|
||||
; word operators:
|
||||
\w a 0 1
|
||||
\w z 0 1
|
||||
\w A 0 1
|
||||
\w Z 0 1
|
||||
\w _ 0 1
|
||||
\w } -1 -1
|
||||
\w ` -1 -1
|
||||
\w [ -1 -1
|
||||
\w @ -1 -1
|
||||
; non-word:
|
||||
\W a -1 -1
|
||||
\W z -1 -1
|
||||
\W A -1 -1
|
||||
\W Z -1 -1
|
||||
\W _ -1 -1
|
||||
\W } 0 1
|
||||
\W ` 0 1
|
||||
\W [ 0 1
|
||||
\W @ 0 1
|
||||
; word start:
|
||||
\<abcd " abcd" 2 6
|
||||
\<ab cab -1 -1
|
||||
\<ab "\nab" 1 3
|
||||
\<tag ::tag 2 5
|
||||
;word end:
|
||||
abc\> abc 0 3
|
||||
abc\> abcd -1 -1
|
||||
abc\> abc\n 0 3
|
||||
abc\> abc:: 0 3
|
||||
; word boundary:
|
||||
\babcd " abcd" 2 6
|
||||
\bab cab -1 -1
|
||||
\bab "\nab" 1 3
|
||||
\btag ::tag 2 5
|
||||
abc\b abc 0 3
|
||||
abc\b abcd -1 -1
|
||||
abc\b abc\n 0 3
|
||||
abc\b abc:: 0 3
|
||||
; within word:
|
||||
\B ab 1 1
|
||||
a\Bb ab 0 2
|
||||
a\B ab 0 1
|
||||
a\B a -1 -1
|
||||
a\B "a " -1 -1
|
||||
|
||||
;
|
||||
; buffer operators:
|
||||
\`abc abc 0 3
|
||||
\`abc \nabc -1 -1
|
||||
\`abc " abc" -1 -1
|
||||
abc\' abc 0 3
|
||||
abc\' abc\n -1 -1
|
||||
abc\' "abc " -1 -1
|
||||
|
||||
;
|
||||
; now follows various complex expressions designed to try and bust the matcher:
|
||||
a(((b)))c abc 0 3 1 2 1 2 1 2
|
||||
a(b|(c))d abd 0 3 1 2 -1 -1
|
||||
a(b|(c))d acd 0 3 1 2 1 2
|
||||
a(b*|c)d abbd 0 4 1 3
|
||||
; just gotta have one DFA-buster, of course
|
||||
a[ab]{20} aaaaabaaaabaaaabaaaab 0 21
|
||||
; and an inline expansion in case somebody gets tricky
|
||||
a[ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab] aaaaabaaaabaaaabaaaab 0 21
|
||||
; and in case somebody just slips in an NFA...
|
||||
a[ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab](wee|week)(knights|night) aaaaabaaaabaaaabaaaabweeknights 0 31 21 24 24 31
|
||||
; one really big one
|
||||
1234567890123456789012345678901234567890123456789012345678901234567890 a1234567890123456789012345678901234567890123456789012345678901234567890b 1 71
|
||||
; fish for problems as brackets go past 8
|
||||
[ab][cd][ef][gh][ij][kl][mn] xacegikmoq 1 8
|
||||
[ab][cd][ef][gh][ij][kl][mn][op] xacegikmoq 1 9
|
||||
[ab][cd][ef][gh][ij][kl][mn][op][qr] xacegikmoqy 1 10
|
||||
[ab][cd][ef][gh][ij][kl][mn][op][q] xacegikmoqy 1 10
|
||||
; and as parenthesis go past 9:
|
||||
(a)(b)(c)(d)(e)(f)(g)(h) zabcdefghi 1 9 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9
|
||||
(a)(b)(c)(d)(e)(f)(g)(h)(i) zabcdefghij 1 10 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10
|
||||
(a)(b)(c)(d)(e)(f)(g)(h)(i)(j) zabcdefghijk 1 11 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11
|
||||
(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k) zabcdefghijkl 1 12 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12
|
||||
(a)d|(b)c abc 1 3 -1 -1 1 2
|
||||
_+((www)|(ftp)|(mailto)):_* "_wwwnocolon _mailto:" 12 20 13 19 -1 -1 -1 -1 13 19
|
||||
|
||||
; subtleties of matching
|
||||
;a(b)?c\1d acd 0 3 -1 -1
|
||||
; POSIX is about the following test:
|
||||
a(b)?c\1d acd -1 -1 -1 -1
|
||||
a(b?c)+d accd 0 4 2 3
|
||||
(wee|week)(knights|night) weeknights 0 10 0 3 3 10
|
||||
.* abc 0 3
|
||||
a(b|(c))d abd 0 3 1 2 -1 -1
|
||||
a(b|(c))d acd 0 3 1 2 1 2
|
||||
a(b*|c|e)d abbd 0 4 1 3
|
||||
a(b*|c|e)d acd 0 3 1 2
|
||||
a(b*|c|e)d ad 0 2 1 1
|
||||
a(b?)c abc 0 3 1 2
|
||||
a(b?)c ac 0 2 1 1
|
||||
a(b+)c abc 0 3 1 2
|
||||
a(b+)c abbbc 0 5 1 4
|
||||
a(b*)c ac 0 2 1 1
|
||||
(a|ab)(bc([de]+)f|cde) abcdef 0 6 0 1 1 6 3 5
|
||||
a([bc]?)c abc 0 3 1 2
|
||||
a([bc]?)c ac 0 2 1 1
|
||||
a([bc]+)c abc 0 3 1 2
|
||||
a([bc]+)c abcc 0 4 1 3
|
||||
a([bc]+)bc abcbc 0 5 1 3
|
||||
a(bb+|b)b abb 0 3 1 2
|
||||
a(bbb+|bb+|b)b abb 0 3 1 2
|
||||
a(bbb+|bb+|b)b abbb 0 4 1 3
|
||||
a(bbb+|bb+|b)bb abbb 0 4 1 2
|
||||
(.*).* abcdef 0 6 0 6
|
||||
(a*)* bc 0 0 0 0
|
||||
xyx*xz xyxxxxyxxxz 5 11
|
||||
|
||||
; do we get the right subexpression when it is used more than once?
|
||||
a(b|c)*d ad 0 2 -1 -1
|
||||
a(b|c)*d abcd 0 4 2 3
|
||||
a(b|c)+d abd 0 3 1 2
|
||||
a(b|c)+d abcd 0 4 2 3
|
||||
a(b|c?)+d ad 0 2 1 1
|
||||
a(b|c){0,0}d ad 0 2 -1 -1
|
||||
a(b|c){0,1}d ad 0 2 -1 -1
|
||||
a(b|c){0,1}d abd 0 3 1 2
|
||||
a(b|c){0,2}d ad 0 2 -1 -1
|
||||
a(b|c){0,2}d abcd 0 4 2 3
|
||||
a(b|c){0,}d ad 0 2 -1 -1
|
||||
a(b|c){0,}d abcd 0 4 2 3
|
||||
a(b|c){1,1}d abd 0 3 1 2
|
||||
a(b|c){1,2}d abd 0 3 1 2
|
||||
a(b|c){1,2}d abcd 0 4 2 3
|
||||
a(b|c){1,}d abd 0 3 1 2
|
||||
a(b|c){1,}d abcd 0 4 2 3
|
||||
a(b|c){2,2}d acbd 0 4 2 3
|
||||
a(b|c){2,2}d abcd 0 4 2 3
|
||||
a(b|c){2,4}d abcd 0 4 2 3
|
||||
a(b|c){2,4}d abcbd 0 5 3 4
|
||||
a(b|c){2,4}d abcbcd 0 6 4 5
|
||||
a(b|c){2,}d abcd 0 4 2 3
|
||||
a(b|c){2,}d abcbd 0 5 3 4
|
||||
; perl only: these conflict with the POSIX test below
|
||||
;a(b|c?)+d abcd 0 4 3 3
|
||||
;a(b+|((c)*))+d abd 0 3 2 2 2 2 -1 -1
|
||||
;a(b+|((c)*))+d abcd 0 4 3 3 3 3 2 3
|
||||
|
||||
; posix only:
|
||||
- match_default extended REG_EXTENDED REG_STARTEND
|
||||
|
||||
a(b|c?)+d abcd 0 4 2 3
|
||||
a(b|((c)*))+d abcd 0 4 2 3 2 3 2 3
|
||||
a(b+|((c)*))+d abd 0 3 1 2 -1 -1 -1 -1
|
||||
a(b+|((c)*))+d abcd 0 4 2 3 2 3 2 3
|
||||
a(b|((c)*))+d ad 0 2 1 1 1 1 -1 -1
|
||||
a(b|((c)*))*d abcd 0 4 2 3 2 3 2 3
|
||||
a(b+|((c)*))*d abd 0 3 1 2 -1 -1 -1 -1
|
||||
a(b+|((c)*))*d abcd 0 4 2 3 2 3 2 3
|
||||
a(b|((c)*))*d ad 0 2 1 1 1 1 -1 -1
|
||||
|
||||
- match_default normal REG_PERL
|
||||
; try to match C++ syntax elements:
|
||||
; line comment:
|
||||
//[^\n]* "++i //here is a line comment\n" 4 28
|
||||
; block comment:
|
||||
/\*([^*]|\*+[^*/])*\*+/ "/* here is a block comment */" 0 29 26 27
|
||||
/\*([^*]|\*+[^*/])*\*+/ "/**/" 0 4 -1 -1
|
||||
/\*([^*]|\*+[^*/])*\*+/ "/***/" 0 5 -1 -1
|
||||
/\*([^*]|\*+[^*/])*\*+/ "/****/" 0 6 -1 -1
|
||||
/\*([^*]|\*+[^*/])*\*+/ "/*****/" 0 7 -1 -1
|
||||
/\*([^*]|\*+[^*/])*\*+/ "/*****/*/" 0 7 -1 -1
|
||||
; preprossor directives:
|
||||
^[[:blank:]]*#([^\n]*\\[[:space:]]+)*[^\n]* "#define some_symbol" 0 19 -1 -1
|
||||
^[[:blank:]]*#([^\n]*\\[[:space:]]+)*[^\n]* "#define some_symbol(x) #x" 0 25 -1 -1
|
||||
; perl only:
|
||||
^[[:blank:]]*#([^\n]*\\[[:space:]]+)*[^\n]* "#define some_symbol(x) \\ \r\n foo();\\\r\n printf(#x);" 0 53 30 42
|
||||
; literals:
|
||||
((0x[[:xdigit:]]+)|([[:digit:]]+))u?((int(8|16|32|64))|L)? 0xFF 0 4 0 4 0 4 -1 -1 -1 -1 -1 -1 -1 -1
|
||||
((0x[[:xdigit:]]+)|([[:digit:]]+))u?((int(8|16|32|64))|L)? 35 0 2 0 2 -1 -1 0 2 -1 -1 -1 -1 -1 -1
|
||||
((0x[[:xdigit:]]+)|([[:digit:]]+))u?((int(8|16|32|64))|L)? 0xFFu 0 5 0 4 0 4 -1 -1 -1 -1 -1 -1 -1 -1
|
||||
((0x[[:xdigit:]]+)|([[:digit:]]+))u?((int(8|16|32|64))|L)? 0xFFL 0 5 0 4 0 4 -1 -1 4 5 -1 -1 -1 -1
|
||||
((0x[[:xdigit:]]+)|([[:digit:]]+))u?((int(8|16|32|64))|L)? 0xFFFFFFFFFFFFFFFFuint64 0 24 0 18 0 18 -1 -1 19 24 19 24 22 24
|
||||
; strings:
|
||||
'([^\\']|\\.)*' '\\x3A' 0 6 4 5
|
||||
'([^\\']|\\.)*' '\\'' 0 4 1 3
|
||||
'([^\\']|\\.)*' '\\n' 0 4 1 3
|
||||
|
||||
; finally try some case insensitive matches:
|
||||
- match_default normal REG_EXTENDED REG_ICASE
|
||||
; upper and lower have no meaning here so they fail, however these
|
||||
; may compile with other libraries...
|
||||
;[[:lower:]] !
|
||||
;[[:upper:]] !
|
||||
0123456789@abcdefghijklmnopqrstuvwxyz\[\\\]\^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ\{\|\} 0123456789@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]\^_`abcdefghijklmnopqrstuvwxyz\{\|\} 0 72
|
||||
|
||||
; known and suspected bugs:
|
||||
- match_default normal REG_EXTENDED
|
||||
\( ( 0 1
|
||||
\) ) 0 1
|
||||
\$ $ 0 1
|
||||
\^ ^ 0 1
|
||||
\. . 0 1
|
||||
\* * 0 1
|
||||
\+ + 0 1
|
||||
\? ? 0 1
|
||||
\[ [ 0 1
|
||||
\] ] 0 1
|
||||
\| | 0 1
|
||||
\\ \\ 0 1
|
||||
# # 0 1
|
||||
\# # 0 1
|
||||
a- a- 0 2
|
||||
\- - 0 1
|
||||
\{ { 0 1
|
||||
\} } 0 1
|
||||
0 0 0 1
|
||||
1 1 0 1
|
||||
9 9 0 1
|
||||
b b 0 1
|
||||
B B 0 1
|
||||
< < 0 1
|
||||
> > 0 1
|
||||
w w 0 1
|
||||
W W 0 1
|
||||
` ` 0 1
|
||||
' ' 0 1
|
||||
\n \n 0 1
|
||||
, , 0 1
|
||||
a a 0 1
|
||||
f f 0 1
|
||||
n n 0 1
|
||||
r r 0 1
|
||||
t t 0 1
|
||||
v v 0 1
|
||||
c c 0 1
|
||||
x x 0 1
|
||||
: : 0 1
|
||||
(\.[[:alnum:]]+){2} "w.a.b " 1 5 3 5
|
||||
|
||||
- match_default normal REG_EXTENDED REG_ICASE
|
||||
a A 0 1
|
||||
A a 0 1
|
||||
[abc]+ abcABC 0 6
|
||||
[ABC]+ abcABC 0 6
|
||||
[a-z]+ abcABC 0 6
|
||||
[A-Z]+ abzANZ 0 6
|
||||
[a-Z]+ abzABZ 0 6
|
||||
[A-z]+ abzABZ 0 6
|
||||
[[:lower:]]+ abyzABYZ 0 8
|
||||
[[:upper:]]+ abzABZ 0 6
|
||||
[[:alpha:]]+ abyzABYZ 0 8
|
||||
[[:alnum:]]+ 09abyzABYZ 0 10
|
||||
|
||||
; word start:
|
||||
\<abcd " abcd" 2 6
|
||||
\<ab cab -1 -1
|
||||
\<ab "\nab" 1 3
|
||||
\<tag ::tag 2 5
|
||||
;word end:
|
||||
abc\> abc 0 3
|
||||
abc\> abcd -1 -1
|
||||
abc\> abc\n 0 3
|
||||
abc\> abc:: 0 3
|
||||
|
||||
; collating elements and rewritten set code:
|
||||
- match_default normal REG_EXTENDED REG_STARTEND
|
||||
;[[.zero.]] 0 0 1
|
||||
;[[.one.]] 1 0 1
|
||||
;[[.two.]] 2 0 1
|
||||
;[[.three.]] 3 0 1
|
||||
[[.a.]] baa 1 2
|
||||
;[[.right-curly-bracket.]] } 0 1
|
||||
;[[.NUL.]] \0 0 1
|
||||
[[:<:]z] !
|
||||
[a[:>:]] !
|
||||
[[=a=]] a 0 1
|
||||
;[[=right-curly-bracket=]] } 0 1
|
||||
- match_default normal REG_EXTENDED REG_STARTEND REG_ICASE
|
||||
[[.A.]] A 0 1
|
||||
[[.A.]] a 0 1
|
||||
[[.A.]-b]+ AaBb 0 4
|
||||
[A-[.b.]]+ AaBb 0 4
|
||||
[[.a.]-B]+ AaBb 0 4
|
||||
[a-[.B.]]+ AaBb 0 4
|
||||
- match_default normal REG_EXTENDED REG_STARTEND
|
||||
[[.a.]-c]+ abcd 0 3
|
||||
[a-[.c.]]+ abcd 0 3
|
||||
[[:alpha:]-a] !
|
||||
[a-[:alpha:]] !
|
||||
|
||||
; try mutli-character ligatures:
|
||||
;[[.ae.]] ae 0 2
|
||||
;[[.ae.]] aE -1 -1
|
||||
;[[.AE.]] AE 0 2
|
||||
;[[.Ae.]] Ae 0 2
|
||||
;[[.ae.]-b] a -1 -1
|
||||
;[[.ae.]-b] b 0 1
|
||||
;[[.ae.]-b] ae 0 2
|
||||
;[a-[.ae.]] a 0 1
|
||||
;[a-[.ae.]] b -1 -1
|
||||
;[a-[.ae.]] ae 0 2
|
||||
- match_default normal REG_EXTENDED REG_STARTEND REG_ICASE
|
||||
;[[.ae.]] AE 0 2
|
||||
;[[.ae.]] Ae 0 2
|
||||
;[[.AE.]] Ae 0 2
|
||||
;[[.Ae.]] aE 0 2
|
||||
;[[.AE.]-B] a -1 -1
|
||||
;[[.Ae.]-b] b 0 1
|
||||
;[[.Ae.]-b] B 0 1
|
||||
;[[.ae.]-b] AE 0 2
|
||||
|
||||
- match_default normal REG_EXTENDED REG_STARTEND REG_NO_POSIX_TEST
|
||||
\s+ "ab ab" 2 5
|
||||
\S+ " abc " 2 5
|
||||
|
||||
- match_default normal REG_EXTENDED REG_STARTEND
|
||||
\`abc abc 0 3
|
||||
\`abc aabc -1 -1
|
||||
abc\' abc 0 3
|
||||
abc\' abcd -1 -1
|
||||
abc\' abc\n\n -1 -1
|
||||
abc\' abc 0 3
|
||||
|
||||
; extended repeat checking to exercise new algorithms:
|
||||
ab.*xy abxy_ 0 4
|
||||
ab.*xy ab_xy_ 0 5
|
||||
ab.*xy abxy 0 4
|
||||
ab.*xy ab_xy 0 5
|
||||
ab.* ab 0 2
|
||||
ab.* ab__ 0 4
|
||||
|
||||
ab.{2,5}xy ab__xy_ 0 6
|
||||
ab.{2,5}xy ab____xy_ 0 8
|
||||
ab.{2,5}xy ab_____xy_ 0 9
|
||||
ab.{2,5}xy ab__xy 0 6
|
||||
ab.{2,5}xy ab_____xy 0 9
|
||||
ab.{2,5} ab__ 0 4
|
||||
ab.{2,5} ab_______ 0 7
|
||||
ab.{2,5}xy ab______xy -1 -1
|
||||
ab.{2,5}xy ab_xy -1 -1
|
||||
|
||||
ab.*?xy abxy_ 0 4
|
||||
ab.*?xy ab_xy_ 0 5
|
||||
ab.*?xy abxy 0 4
|
||||
ab.*?xy ab_xy 0 5
|
||||
ab.*? ab 0 2
|
||||
ab.*? ab__ 0 4
|
||||
|
||||
ab.{2,5}?xy ab__xy_ 0 6
|
||||
ab.{2,5}?xy ab____xy_ 0 8
|
||||
ab.{2,5}?xy ab_____xy_ 0 9
|
||||
ab.{2,5}?xy ab__xy 0 6
|
||||
ab.{2,5}?xy ab_____xy 0 9
|
||||
ab.{2,5}? ab__ 0 4
|
||||
ab.{2,5}? ab_______ 0 7
|
||||
ab.{2,5}?xy ab______xy -1 -1
|
||||
ab.{2,5}xy ab_xy -1 -1
|
||||
|
||||
; again but with slower algorithm variant:
|
||||
- match_default REG_EXTENDED
|
||||
; now again for single character repeats:
|
||||
|
||||
ab_*xy abxy_ 0 4
|
||||
ab_*xy ab_xy_ 0 5
|
||||
ab_*xy abxy 0 4
|
||||
ab_*xy ab_xy 0 5
|
||||
ab_* ab 0 2
|
||||
ab_* ab__ 0 4
|
||||
|
||||
ab_{2,5}xy ab__xy_ 0 6
|
||||
ab_{2,5}xy ab____xy_ 0 8
|
||||
ab_{2,5}xy ab_____xy_ 0 9
|
||||
ab_{2,5}xy ab__xy 0 6
|
||||
ab_{2,5}xy ab_____xy 0 9
|
||||
ab_{2,5} ab__ 0 4
|
||||
ab_{2,5} ab_______ 0 7
|
||||
ab_{2,5}xy ab______xy -1 -1
|
||||
ab_{2,5}xy ab_xy -1 -1
|
||||
|
||||
ab_*?xy abxy_ 0 4
|
||||
ab_*?xy ab_xy_ 0 5
|
||||
ab_*?xy abxy 0 4
|
||||
ab_*?xy ab_xy 0 5
|
||||
ab_*? ab 0 2
|
||||
ab_*? ab__ 0 4
|
||||
|
||||
ab_{2,5}?xy ab__xy_ 0 6
|
||||
ab_{2,5}?xy ab____xy_ 0 8
|
||||
ab_{2,5}?xy ab_____xy_ 0 9
|
||||
ab_{2,5}?xy ab__xy 0 6
|
||||
ab_{2,5}?xy ab_____xy 0 9
|
||||
ab_{2,5}? ab__ 0 4
|
||||
ab_{2,5}? ab_______ 0 7
|
||||
ab_{2,5}?xy ab______xy -1 -1
|
||||
ab_{2,5}xy ab_xy -1 -1
|
||||
|
||||
; and again for sets:
|
||||
ab[_,;]*xy abxy_ 0 4
|
||||
ab[_,;]*xy ab_xy_ 0 5
|
||||
ab[_,;]*xy abxy 0 4
|
||||
ab[_,;]*xy ab_xy 0 5
|
||||
ab[_,;]* ab 0 2
|
||||
ab[_,;]* ab__ 0 4
|
||||
|
||||
ab[_,;]{2,5}xy ab__xy_ 0 6
|
||||
ab[_,;]{2,5}xy ab____xy_ 0 8
|
||||
ab[_,;]{2,5}xy ab_____xy_ 0 9
|
||||
ab[_,;]{2,5}xy ab__xy 0 6
|
||||
ab[_,;]{2,5}xy ab_____xy 0 9
|
||||
ab[_,;]{2,5} ab__ 0 4
|
||||
ab[_,;]{2,5} ab_______ 0 7
|
||||
ab[_,;]{2,5}xy ab______xy -1 -1
|
||||
ab[_,;]{2,5}xy ab_xy -1 -1
|
||||
|
||||
ab[_,;]*?xy abxy_ 0 4
|
||||
ab[_,;]*?xy ab_xy_ 0 5
|
||||
ab[_,;]*?xy abxy 0 4
|
||||
ab[_,;]*?xy ab_xy 0 5
|
||||
ab[_,;]*? ab 0 2
|
||||
ab[_,;]*? ab__ 0 4
|
||||
|
||||
ab[_,;]{2,5}?xy ab__xy_ 0 6
|
||||
ab[_,;]{2,5}?xy ab____xy_ 0 8
|
||||
ab[_,;]{2,5}?xy ab_____xy_ 0 9
|
||||
ab[_,;]{2,5}?xy ab__xy 0 6
|
||||
ab[_,;]{2,5}?xy ab_____xy 0 9
|
||||
ab[_,;]{2,5}? ab__ 0 4
|
||||
ab[_,;]{2,5}? ab_______ 0 7
|
||||
ab[_,;]{2,5}?xy ab______xy -1 -1
|
||||
ab[_,;]{2,5}xy ab_xy -1 -1
|
||||
|
||||
; and again for tricky sets with digraphs:
|
||||
;ab[_[.ae.]]*xy abxy_ 0 4
|
||||
;ab[_[.ae.]]*xy ab_xy_ 0 5
|
||||
;ab[_[.ae.]]*xy abxy 0 4
|
||||
;ab[_[.ae.]]*xy ab_xy 0 5
|
||||
;ab[_[.ae.]]* ab 0 2
|
||||
;ab[_[.ae.]]* ab__ 0 4
|
||||
|
||||
;ab[_[.ae.]]{2,5}xy ab__xy_ 0 6
|
||||
;ab[_[.ae.]]{2,5}xy ab____xy_ 0 8
|
||||
;ab[_[.ae.]]{2,5}xy ab_____xy_ 0 9
|
||||
;ab[_[.ae.]]{2,5}xy ab__xy 0 6
|
||||
;ab[_[.ae.]]{2,5}xy ab_____xy 0 9
|
||||
;ab[_[.ae.]]{2,5} ab__ 0 4
|
||||
;ab[_[.ae.]]{2,5} ab_______ 0 7
|
||||
;ab[_[.ae.]]{2,5}xy ab______xy -1 -1
|
||||
;ab[_[.ae.]]{2,5}xy ab_xy -1 -1
|
||||
|
||||
;ab[_[.ae.]]*?xy abxy_ 0 4
|
||||
;ab[_[.ae.]]*?xy ab_xy_ 0 5
|
||||
;ab[_[.ae.]]*?xy abxy 0 4
|
||||
;ab[_[.ae.]]*?xy ab_xy 0 5
|
||||
;ab[_[.ae.]]*? ab 0 2
|
||||
;ab[_[.ae.]]*? ab__ 0 2
|
||||
|
||||
;ab[_[.ae.]]{2,5}?xy ab__xy_ 0 6
|
||||
;ab[_[.ae.]]{2,5}?xy ab____xy_ 0 8
|
||||
;ab[_[.ae.]]{2,5}?xy ab_____xy_ 0 9
|
||||
;ab[_[.ae.]]{2,5}?xy ab__xy 0 6
|
||||
;ab[_[.ae.]]{2,5}?xy ab_____xy 0 9
|
||||
;ab[_[.ae.]]{2,5}? ab__ 0 4
|
||||
;ab[_[.ae.]]{2,5}? ab_______ 0 4
|
||||
;ab[_[.ae.]]{2,5}?xy ab______xy -1 -1
|
||||
;ab[_[.ae.]]{2,5}xy ab_xy -1 -1
|
||||
|
||||
; new bugs detected in spring 2003:
|
||||
- normal match_continuous REG_NO_POSIX_TEST
|
||||
b abc 1 2
|
||||
|
||||
() abc 0 0 0 0
|
||||
^() abc 0 0 0 0
|
||||
^()+ abc 0 0 0 0
|
||||
^(){1} abc 0 0 0 0
|
||||
^(){2} abc 0 0 0 0
|
||||
^((){2}) abc 0 0 0 0 0 0
|
||||
() "" 0 0 0 0
|
||||
()\1 "" 0 0 0 0
|
||||
()\1 a 0 0 0 0
|
||||
a()\1b ab 0 2 1 1
|
||||
a()b\1 ab 0 2 1 1
|
||||
|
||||
; subtleties of matching with no sub-expressions marked
|
||||
- normal match_nosubs REG_NO_POSIX_TEST
|
||||
a(b?c)+d accd 0 4
|
||||
(wee|week)(knights|night) weeknights 0 10
|
||||
.* abc 0 3
|
||||
a(b|(c))d abd 0 3
|
||||
a(b|(c))d acd 0 3
|
||||
a(b*|c|e)d abbd 0 4
|
||||
a(b*|c|e)d acd 0 3
|
||||
a(b*|c|e)d ad 0 2
|
||||
a(b?)c abc 0 3
|
||||
a(b?)c ac 0 2
|
||||
a(b+)c abc 0 3
|
||||
a(b+)c abbbc 0 5
|
||||
a(b*)c ac 0 2
|
||||
(a|ab)(bc([de]+)f|cde) abcdef 0 6
|
||||
a([bc]?)c abc 0 3
|
||||
a([bc]?)c ac 0 2
|
||||
a([bc]+)c abc 0 3
|
||||
a([bc]+)c abcc 0 4
|
||||
a([bc]+)bc abcbc 0 5
|
||||
a(bb+|b)b abb 0 3
|
||||
a(bbb+|bb+|b)b abb 0 3
|
||||
a(bbb+|bb+|b)b abbb 0 4
|
||||
a(bbb+|bb+|b)bb abbb 0 4
|
||||
(.*).* abcdef 0 6
|
||||
(a*)* bc 0 0
|
||||
|
||||
- normal nosubs REG_NO_POSIX_TEST
|
||||
a(b?c)+d accd 0 4
|
||||
(wee|week)(knights|night) weeknights 0 10
|
||||
.* abc 0 3
|
||||
a(b|(c))d abd 0 3
|
||||
a(b|(c))d acd 0 3
|
||||
a(b*|c|e)d abbd 0 4
|
||||
a(b*|c|e)d acd 0 3
|
||||
a(b*|c|e)d ad 0 2
|
||||
a(b?)c abc 0 3
|
||||
a(b?)c ac 0 2
|
||||
a(b+)c abc 0 3
|
||||
a(b+)c abbbc 0 5
|
||||
a(b*)c ac 0 2
|
||||
(a|ab)(bc([de]+)f|cde) abcdef 0 6
|
||||
a([bc]?)c abc 0 3
|
||||
a([bc]?)c ac 0 2
|
||||
a([bc]+)c abc 0 3
|
||||
a([bc]+)c abcc 0 4
|
||||
a([bc]+)bc abcbc 0 5
|
||||
a(bb+|b)b abb 0 3
|
||||
a(bbb+|bb+|b)b abb 0 3
|
||||
a(bbb+|bb+|b)b abbb 0 4
|
||||
a(bbb+|bb+|b)bb abbb 0 4
|
||||
(.*).* abcdef 0 6
|
||||
(a*)* bc 0 0
|
||||
|
||||
+10
-18
@@ -1,23 +1,14 @@
|
||||
CLEANFILES = tmp* core *.core $(EXTRA_PROGRAMS) *.*out *.log
|
||||
|
||||
TESTS = $(check_PROGRAMS) $(SEDTESTS)
|
||||
SEDTESTS =
|
||||
|
||||
LDADD = ../lib/libsed.a
|
||||
noinst_HEADERS = testcases.h ptestcases.h
|
||||
AM_CPPFLAGS = -I../lib
|
||||
pcretest_LDADD = ../pcre/libpcre.a ../lib/libsed.a
|
||||
pcretest_DEPENDENCIES = ../pcre/libpcre.a ../lib/libsed.a
|
||||
check_PROGRAMS = pcretest
|
||||
AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/lib -I$(top_srcdir)/pcre
|
||||
|
||||
if TEST_REGEX
|
||||
check_PROGRAMS = bug-regex7 \
|
||||
bug-regex8 bug-regex9 bug-regex10 bug-regex11 bug-regex12 \
|
||||
bug-regex13 bug-regex14 bug-regex15 bug-regex16 \
|
||||
bug-regex21 tst-pcre tst-boost runtests runptests tst-rxspencer
|
||||
|
||||
SEDTESTS += space
|
||||
endif
|
||||
|
||||
SEDTESTS += \
|
||||
enable sep inclib 8bit newjis xabcx dollar noeol noeolw \
|
||||
SEDTESTS = \
|
||||
space enable sep inclib 8bit newjis xabcx dollar noeol noeolw \
|
||||
numsub numsub2 numsub3 numsub4 numsub5 0range bkslashes \
|
||||
head madding mac-mf empty xbxcx xbxcx3 recall xemacs \
|
||||
fasts uniq manis khadafy linecnt eval distrib 8to7 \
|
||||
@@ -28,9 +19,10 @@ SEDTESTS += \
|
||||
|
||||
TESTS_ENVIRONMENT = MAKE="$(MAKE)" VERSION="$(VERSION)" $(srcdir)/runtest
|
||||
|
||||
EXTRA_DIST = \
|
||||
PCRE.tests BOOST.tests SPENCER.tests \
|
||||
runtest Makefile.tests \
|
||||
EXTRA_DIST = runtest Makefile.tests \
|
||||
pcre1.good pcre1.inp pcre1p.good \
|
||||
pcre2.good pcre2.inp pcre2p.good \
|
||||
pcre3.good pcre3.inp pcre3p.good \
|
||||
0range.good 0range.inp 0range.sed \
|
||||
8bit.good 8bit.inp 8bit.sed \
|
||||
8to7.good 8to7.inp 8to7.sed \
|
||||
|
||||
@@ -1,528 +0,0 @@
|
||||
# Copyright 1992, 1993, 1994, 1997 Henry Spencer. All rights reserved.
|
||||
# This software is not subject to any license of the American Telephone
|
||||
# and Telegraph Company or of the Regents of the University of California.
|
||||
#
|
||||
# Permission is granted to anyone to use this software for any purpose on
|
||||
# any computer system, and to alter it and redistribute it, subject
|
||||
# to the following restrictions:
|
||||
#
|
||||
# 1. The author is not responsible for the consequences of use of this
|
||||
# software, no matter how awful, even if they arise from flaws in it.
|
||||
#
|
||||
# 2. The origin of this software must not be misrepresented, either by
|
||||
# explicit claim or by omission. Since few users ever read sources,
|
||||
# credits must appear in the documentation.
|
||||
#
|
||||
# 3. Altered versions must be plainly marked as such, and must not be
|
||||
# misrepresented as being the original software. Since few users
|
||||
# ever read sources, credits must appear in the documentation.
|
||||
#
|
||||
# 4. This notice may not be removed or altered.
|
||||
#
|
||||
# regular expression test set
|
||||
# Lines are at least three fields, separated by one or more tabs. "" stands
|
||||
# for an empty field. First field is an RE. Second field is flags. If
|
||||
# C flag given, regcomp() is expected to fail, and the third field is the
|
||||
# error name (minus the leading REG_).
|
||||
#
|
||||
# Otherwise it is expected to succeed, and the third field is the string to
|
||||
# try matching it against. If there is no fourth field, the match is
|
||||
# expected to fail. If there is a fourth field, it is the substring that
|
||||
# the RE is expected to match. If there is a fifth field, it is a comma-
|
||||
# separated list of what the subexpressions should match, with - indicating
|
||||
# no match for that one. In both the fourth and fifth fields, a (sub)field
|
||||
# starting with @ indicates that the (sub)expression is expected to match
|
||||
# a null string followed by the stuff after the @; this provides a way to
|
||||
# test where null strings match. The character `N' in REs and strings
|
||||
# is newline, `S' is space, `T' is tab, `Z' is NUL.
|
||||
#
|
||||
# The full list of flags:
|
||||
# - placeholder, does nothing
|
||||
# b RE is a BRE, not an ERE
|
||||
# & try it as both an ERE and a BRE
|
||||
# C regcomp() error expected, third field is error name
|
||||
# i REG_ICASE
|
||||
# m ("mundane") REG_NOSPEC
|
||||
# s REG_NOSUB (not really testable)
|
||||
# n REG_NEWLINE
|
||||
# ^ REG_NOTBOL
|
||||
# $ REG_NOTEOL
|
||||
# # REG_STARTEND (see below)
|
||||
# p REG_PEND
|
||||
#
|
||||
# For REG_STARTEND, the start/end offsets are those of the substring
|
||||
# enclosed in ().
|
||||
|
||||
# basics
|
||||
a & a a
|
||||
abc & abc abc
|
||||
abc|de - abc abc
|
||||
a|b|c - abc a
|
||||
|
||||
# parentheses and perversions thereof
|
||||
a(b)c - abc abc
|
||||
a\(b\)c b abc abc
|
||||
a( C EPAREN
|
||||
a( b a( a(
|
||||
a\( - a( a(
|
||||
a\( bC EPAREN
|
||||
a\(b bC EPAREN
|
||||
a(b C EPAREN
|
||||
a(b b a(b a(b
|
||||
# gag me with a right parenthesis -- 1003.2 goofed here (my fault, partly)
|
||||
a) - a) a)
|
||||
) - ) )
|
||||
# end gagging (in a just world, those *should* give EPAREN)
|
||||
a) b a) a)
|
||||
a\) bC EPAREN
|
||||
\) bC EPAREN
|
||||
a()b - ab ab
|
||||
a\(\)b b ab ab
|
||||
|
||||
# anchoring and REG_NEWLINE
|
||||
^abc$ & abc abc
|
||||
a^b - a^b
|
||||
a^b b a^b a^b
|
||||
a$b - a$b
|
||||
a$b b a$b a$b
|
||||
^ & abc @abc
|
||||
$ & abc @
|
||||
^$ & "" @
|
||||
$^ - "" @
|
||||
\($\)\(^\) b "" @
|
||||
# stop retching, those are legitimate (although disgusting)
|
||||
^^ - "" @
|
||||
$$ - "" @
|
||||
b$ & abNc
|
||||
b$ &n abNc b
|
||||
^b$ & aNbNc
|
||||
^b$ &n aNbNc b
|
||||
^$ &n aNNb @Nb
|
||||
^$ n abc
|
||||
^$ n abcN @
|
||||
$^ n aNNb @Nb
|
||||
\($\)\(^\) bn aNNb @Nb
|
||||
^^ n^ aNNb @Nb
|
||||
$$ n aNNb @NN
|
||||
^a ^ a
|
||||
a$ $ a
|
||||
^a ^n aNb
|
||||
^b ^n aNb b
|
||||
a$ $n bNa
|
||||
b$ $n bNa b
|
||||
a*(^b$)c* - b b
|
||||
a*\(^b$\)c* b b b
|
||||
|
||||
# certain syntax errors and non-errors
|
||||
| C EMPTY
|
||||
| b | |
|
||||
* C BADRPT
|
||||
* b * *
|
||||
+ C BADRPT
|
||||
? C BADRPT
|
||||
"" &C EMPTY
|
||||
() - abc @abc
|
||||
\(\) b abc @abc
|
||||
a||b C EMPTY
|
||||
|ab C EMPTY
|
||||
ab| C EMPTY
|
||||
(|a)b C EMPTY
|
||||
(a|)b C EMPTY
|
||||
(*a) C BADRPT
|
||||
(+a) C BADRPT
|
||||
(?a) C BADRPT
|
||||
({1}a) C BADRPT
|
||||
\(\{1\}a\) bC BADRPT
|
||||
(a|*b) C BADRPT
|
||||
(a|+b) C BADRPT
|
||||
(a|?b) C BADRPT
|
||||
(a|{1}b) C BADRPT
|
||||
^* C BADRPT
|
||||
^* b * *
|
||||
^+ C BADRPT
|
||||
^? C BADRPT
|
||||
^{1} C BADRPT
|
||||
^\{1\} bC BADRPT
|
||||
|
||||
# metacharacters, backslashes
|
||||
a.c & abc abc
|
||||
a[bc]d & abd abd
|
||||
a\*c & a*c a*c
|
||||
a\\b & a\b a\b
|
||||
a\\\*b & a\*b a\*b
|
||||
# The following test is wrong. Using \b in an BRE or ERE is undefined.
|
||||
# a\bc & abc abc
|
||||
a\ &C EESCAPE
|
||||
a\\bc & a\bc a\bc
|
||||
\{ bC BADRPT
|
||||
a\[b & a[b a[b
|
||||
a[b &C EBRACK
|
||||
# trailing $ is a peculiar special case for the BRE code
|
||||
a$ & a a
|
||||
a$ & a$
|
||||
a\$ & a
|
||||
a\$ & a$ a$
|
||||
a\\$ & a
|
||||
a\\$ & a$
|
||||
a\\$ & a\$
|
||||
a\\$ & a\ a\
|
||||
|
||||
# back references, ugh
|
||||
a\(b\)\2c bC ESUBREG
|
||||
a\(b\1\)c bC ESUBREG
|
||||
a\(b*\)c\1d b abbcbbd abbcbbd bb
|
||||
a\(b*\)c\1d b abbcbd
|
||||
a\(b*\)c\1d b abbcbbbd
|
||||
^\(.\)\1 b abc
|
||||
a\([bc]\)\1d b abcdabbd abbd b
|
||||
a\(\([bc]\)\2\)*d b abbccd abbccd
|
||||
a\(\([bc]\)\2\)*d b abbcbd
|
||||
# actually, this next one probably ought to fail, but the spec is unclear
|
||||
a\(\(b\)*\2\)*d b abbbd abbbd
|
||||
# here is a case that no NFA implementation does right
|
||||
\(ab*\)[ab]*\1 b ababaaa ababaaa a
|
||||
# check out normal matching in the presence of back refs
|
||||
\(a\)\1bcd b aabcd aabcd
|
||||
\(a\)\1bc*d b aabcd aabcd
|
||||
\(a\)\1bc*d b aabd aabd
|
||||
\(a\)\1bc*d b aabcccd aabcccd
|
||||
\(a\)\1bc*[ce]d b aabcccd aabcccd
|
||||
^\(a\)\1b\(c\)*cd$ b aabcccd aabcccd
|
||||
|
||||
# ordinary repetitions
|
||||
ab*c & abc abc
|
||||
ab+c - abc abc
|
||||
ab?c - abc abc
|
||||
a\(*\)b b a*b a*b
|
||||
a\(**\)b b ab ab
|
||||
a\(***\)b bC BADRPT
|
||||
*a b *a *a
|
||||
**a b a a
|
||||
***a bC BADRPT
|
||||
|
||||
# the dreaded bounded repetitions
|
||||
# The following two tests are not correct:
|
||||
#{ & { {
|
||||
#{abc & {abc {abc
|
||||
# '{' is always a special char outside bracket expressions. So test ony BRE:
|
||||
{ b { {
|
||||
{abc b {abc {abc
|
||||
{1 C BADRPT
|
||||
{1} C BADRPT
|
||||
# Same reason as for the two tests above:
|
||||
#a{b & a{b a{b
|
||||
a{b b a{b a{b
|
||||
a{1}b - ab ab
|
||||
a\{1\}b b ab ab
|
||||
a{1,}b - ab ab
|
||||
a\{1,\}b b ab ab
|
||||
a{1,2}b - aab aab
|
||||
a\{1,2\}b b aab aab
|
||||
a{1 C EBRACE
|
||||
a\{1 bC EBRACE
|
||||
a{1a C EBRACE
|
||||
a\{1a bC EBRACE
|
||||
a{1a} C BADBR
|
||||
a\{1a\} bC BADBR
|
||||
# These four tests checks for undefined behavior. Our implementation does
|
||||
# something different.
|
||||
#a{,2} - a{,2} a{,2}
|
||||
#a\{,2\} bC BADBR
|
||||
#a{,} - a{,} a{,}
|
||||
#a\{,\} bC BADBR
|
||||
a{1,x} C BADBR
|
||||
a\{1,x\} bC BADBR
|
||||
a{1,x C EBRACE
|
||||
a\{1,x bC EBRACE
|
||||
# These two tests probably fails due to an arbitrary limit on the number of
|
||||
# repetitions in the other implementation.
|
||||
#a{300} C BADBR
|
||||
#a\{300\} bC BADBR
|
||||
a{1,0} C BADBR
|
||||
a\{1,0\} bC BADBR
|
||||
ab{0,0}c - abcac ac
|
||||
ab\{0,0\}c b abcac ac
|
||||
ab{0,1}c - abcac abc
|
||||
ab\{0,1\}c b abcac abc
|
||||
ab{0,3}c - abbcac abbc
|
||||
ab\{0,3\}c b abbcac abbc
|
||||
ab{1,1}c - acabc abc
|
||||
ab\{1,1\}c b acabc abc
|
||||
ab{1,3}c - acabc abc
|
||||
ab\{1,3\}c b acabc abc
|
||||
ab{2,2}c - abcabbc abbc
|
||||
ab\{2,2\}c b abcabbc abbc
|
||||
ab{2,4}c - abcabbc abbc
|
||||
ab\{2,4\}c b abcabbc abbc
|
||||
((a{1,10}){1,10}){1,10} - a a a,a
|
||||
|
||||
# multiple repetitions
|
||||
# Wow, there is serious disconnect here. The ERE grammar is like this:
|
||||
# ERE_expression : one_char_or_coll_elem_ERE
|
||||
# | '^'
|
||||
# | '$'
|
||||
# | '(' extended_reg_exp ')'
|
||||
# | ERE_expression ERE_dupl_symbol
|
||||
# ;
|
||||
# where ERE_dupl_symbol is any of the repetition methods. It is clear from
|
||||
# this that consecutive repetition is OK. On top of this, the one test not
|
||||
# marked as failing must fail. For BREs the situation is different, so we
|
||||
# use the four tests.
|
||||
#a** &C BADRPT
|
||||
a** bC BADRPT
|
||||
#a++ C BADRPT
|
||||
#a?? C BADRPT
|
||||
#a*+ C BADRPT
|
||||
#a*? C BADRPT
|
||||
#a+* C BADRPT
|
||||
#a+? C BADRPT
|
||||
#a?* C BADRPT
|
||||
#a?+ C BADRPT
|
||||
#a{1}{1} C BADRPT
|
||||
#a*{1} C BADRPT
|
||||
#a+{1} C BADRPT
|
||||
#a?{1} C BADRPT
|
||||
#a{1}* C BADRPT
|
||||
#a{1}+ C BADRPT
|
||||
#a{1}? C BADRPT
|
||||
#a*{b} - a{b} a{b}
|
||||
a\{1\}\{1\} bC BADRPT
|
||||
a*\{1\} bC BADRPT
|
||||
a\{1\}* bC BADRPT
|
||||
|
||||
# brackets, and numerous perversions thereof
|
||||
a[b]c & abc abc
|
||||
a[ab]c & abc abc
|
||||
a[^ab]c & adc adc
|
||||
a[]b]c & a]c a]c
|
||||
a[[b]c & a[c a[c
|
||||
a[-b]c & a-c a-c
|
||||
a[^]b]c & adc adc
|
||||
a[^-b]c & adc adc
|
||||
a[b-]c & a-c a-c
|
||||
a[b &C EBRACK
|
||||
a[] &C EBRACK
|
||||
a[1-3]c & a2c a2c
|
||||
a[3-1]c &C ERANGE
|
||||
a[1-3-5]c &C ERANGE
|
||||
a[[.-.]--]c & a-c a-c
|
||||
# I don't thing the error value should be ERANGE since a[1-] would be
|
||||
# valid, too. Expect EBRACK.
|
||||
#a[1- &C ERANGE
|
||||
a[1- &C EBRACK
|
||||
a[[. &C EBRACK
|
||||
a[[.x &C EBRACK
|
||||
a[[.x. &C EBRACK
|
||||
a[[.x.] &C EBRACK
|
||||
a[[.x.]] & ax ax
|
||||
a[[.x,.]] &C ECOLLATE
|
||||
# This test is invalid. "one" is no collating symbol in any standardized
|
||||
# locale.
|
||||
# a[[.one.]]b & a1b a1b
|
||||
a[[.notdef.]]b &C ECOLLATE
|
||||
a[[.].]]b & a]b a]b
|
||||
a[[:alpha:]]c & abc abc
|
||||
a[[:notdef:]]c &C ECTYPE
|
||||
a[[: &C EBRACK
|
||||
a[[:alpha &C EBRACK
|
||||
a[[:alpha:] &C EBRACK
|
||||
a[[:alpha,:] &C ECTYPE
|
||||
a[[:]:]]b &C ECTYPE
|
||||
a[[:-:]]b &C ECTYPE
|
||||
a[[:alph:]] &C ECTYPE
|
||||
a[[:alphabet:]] &C ECTYPE
|
||||
[[:alnum:]]+ - -%@a0X- a0X
|
||||
[[:alpha:]]+ - -%@aX0- aX
|
||||
[[:blank:]]+ - aSSTb SST
|
||||
[[:cntrl:]]+ - aNTb NT
|
||||
[[:digit:]]+ - a019b 019
|
||||
[[:graph:]]+ - Sa%bS a%b
|
||||
[[:lower:]]+ - AabC ab
|
||||
[[:print:]]+ - NaSbN aSb
|
||||
[[:punct:]]+ - S%-&T %-&
|
||||
[[:space:]]+ - aSNTb SNT
|
||||
[[:upper:]]+ - aBCd BC
|
||||
[[:xdigit:]]+ - p0f3Cq 0f3C
|
||||
a[[=b=]]c & abc abc
|
||||
a[[= &C EBRACK
|
||||
a[[=b &C EBRACK
|
||||
a[[=b= &C EBRACK
|
||||
a[[=b=] &C EBRACK
|
||||
a[[=b,=]] &C ECOLLATE
|
||||
# This test is invalid. "one" is no collating symbol in any standardized
|
||||
# locale.
|
||||
#a[[=one=]]b & a1b a1b
|
||||
|
||||
# complexities
|
||||
a(((b)))c - abc abc
|
||||
a(b|(c))d - abd abd
|
||||
a(b*|c)d - abbd abbd
|
||||
# just gotta have one DFA-buster, of course
|
||||
a[ab]{20} - aaaaabaaaabaaaabaaaab aaaaabaaaabaaaabaaaab
|
||||
# and an inline expansion in case somebody gets tricky
|
||||
a[ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab] - aaaaabaaaabaaaabaaaab aaaaabaaaabaaaabaaaab
|
||||
# and in case somebody just slips in an NFA...
|
||||
a[ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab](wee|week)(knights|night) - aaaaabaaaabaaaabaaaabweeknights aaaaabaaaabaaaabaaaabweeknights
|
||||
# fish for anomalies as the number of states passes 32
|
||||
12345678901234567890123456789 - a12345678901234567890123456789b 12345678901234567890123456789
|
||||
123456789012345678901234567890 - a123456789012345678901234567890b 123456789012345678901234567890
|
||||
1234567890123456789012345678901 - a1234567890123456789012345678901b 1234567890123456789012345678901
|
||||
12345678901234567890123456789012 - a12345678901234567890123456789012b 12345678901234567890123456789012
|
||||
123456789012345678901234567890123 - a123456789012345678901234567890123b 123456789012345678901234567890123
|
||||
# and one really big one, beyond any plausible word width
|
||||
1234567890123456789012345678901234567890123456789012345678901234567890 - a1234567890123456789012345678901234567890123456789012345678901234567890b 1234567890123456789012345678901234567890123456789012345678901234567890
|
||||
# fish for problems as brackets go past 8
|
||||
[ab][cd][ef][gh][ij][kl][mn] - xacegikmoq acegikm
|
||||
[ab][cd][ef][gh][ij][kl][mn][op] - xacegikmoq acegikmo
|
||||
[ab][cd][ef][gh][ij][kl][mn][op][qr] - xacegikmoqy acegikmoq
|
||||
[ab][cd][ef][gh][ij][kl][mn][op][q] - xacegikmoqy acegikmoq
|
||||
|
||||
# subtleties of matching
|
||||
abc & xabcy abc
|
||||
a\(b\)?c\1d b acd
|
||||
aBc i Abc Abc
|
||||
a[Bc]*d i abBCcd abBCcd
|
||||
0[[:upper:]]1 &i 0a1 0a1
|
||||
0[[:lower:]]1 &i 0A1 0A1
|
||||
a[^b]c &i abc
|
||||
a[^b]c &i aBc
|
||||
a[^b]c &i adc adc
|
||||
[a]b[c] - abc abc
|
||||
[a]b[a] - aba aba
|
||||
[abc]b[abc] - abc abc
|
||||
[abc]b[abd] - abd abd
|
||||
a(b?c)+d - accd accd
|
||||
(wee|week)(knights|night) - weeknights weeknights
|
||||
(we|wee|week|frob)(knights|night|day) - weeknights weeknights
|
||||
a[bc]d - xyzaaabcaababdacd abd
|
||||
a[ab]c - aaabc abc
|
||||
abc s abc abc
|
||||
a* & b @b
|
||||
|
||||
# Let's have some fun -- try to match a C comment.
|
||||
# first the obvious, which looks okay at first glance...
|
||||
/\*.*\*/ - /*x*/ /*x*/
|
||||
# but...
|
||||
/\*.*\*/ - /*x*/y/*z*/ /*x*/y/*z*/
|
||||
# okay, we must not match */ inside; try to do that...
|
||||
/\*([^*]|\*[^/])*\*/ - /*x*/ /*x*/
|
||||
/\*([^*]|\*[^/])*\*/ - /*x*/y/*z*/ /*x*/
|
||||
# but...
|
||||
/\*([^*]|\*[^/])*\*/ - /*x**/y/*z*/ /*x**/y/*z*/
|
||||
# and a still fancier version, which does it right (I think)...
|
||||
/\*([^*]|\*+[^*/])*\*+/ - /*x*/ /*x*/
|
||||
/\*([^*]|\*+[^*/])*\*+/ - /*x*/y/*z*/ /*x*/
|
||||
/\*([^*]|\*+[^*/])*\*+/ - /*x**/y/*z*/ /*x**/
|
||||
/\*([^*]|\*+[^*/])*\*+/ - /*x****/y/*z*/ /*x****/
|
||||
/\*([^*]|\*+[^*/])*\*+/ - /*x**x*/y/*z*/ /*x**x*/
|
||||
/\*([^*]|\*+[^*/])*\*+/ - /*x***x/y/*z*/ /*x***x/y/*z*/
|
||||
|
||||
# subexpressions
|
||||
.* - abc abc -
|
||||
a(b)(c)d - abcd abcd b,c
|
||||
a(((b)))c - abc abc b,b,b
|
||||
a(b|(c))d - abd abd b,-
|
||||
a(b*|c|e)d - abbd abbd bb
|
||||
a(b*|c|e)d - acd acd c
|
||||
a(b*|c|e)d - ad ad @d
|
||||
a(b?)c - abc abc b
|
||||
a(b?)c - ac ac @c
|
||||
a(b+)c - abc abc b
|
||||
a(b+)c - abbbc abbbc bbb
|
||||
a(b*)c - ac ac @c
|
||||
(a|ab)(bc([de]+)f|cde) - abcdef abcdef a,bcdef,de
|
||||
# the regression tester only asks for 9 subexpressions
|
||||
a(b)(c)(d)(e)(f)(g)(h)(i)(j)k - abcdefghijk abcdefghijk b,c,d,e,f,g,h,i,j
|
||||
a(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)l - abcdefghijkl abcdefghijkl b,c,d,e,f,g,h,i,j,k
|
||||
a([bc]?)c - abc abc b
|
||||
a([bc]?)c - ac ac @c
|
||||
a([bc]+)c - abc abc b
|
||||
a([bc]+)c - abcc abcc bc
|
||||
a([bc]+)bc - abcbc abcbc bc
|
||||
a(bb+|b)b - abb abb b
|
||||
a(bbb+|bb+|b)b - abb abb b
|
||||
a(bbb+|bb+|b)b - abbb abbb bb
|
||||
a(bbb+|bb+|b)bb - abbb abbb b
|
||||
(.*).* - abcdef abcdef abcdef
|
||||
(a*)* - bc @b @b
|
||||
|
||||
# do we get the right subexpression when it is used more than once?
|
||||
a(b|c)*d - ad ad -
|
||||
a(b|c)*d - abcd abcd c
|
||||
a(b|c)+d - abd abd b
|
||||
a(b|c)+d - abcd abcd c
|
||||
a(b|c?)+d - ad ad @d
|
||||
a(b|c?)+d - abcd abcd c
|
||||
a(b|c){0,0}d - ad ad -
|
||||
a(b|c){0,1}d - ad ad -
|
||||
a(b|c){0,1}d - abd abd b
|
||||
a(b|c){0,2}d - ad ad -
|
||||
a(b|c){0,2}d - abcd abcd c
|
||||
a(b|c){0,}d - ad ad -
|
||||
a(b|c){0,}d - abcd abcd c
|
||||
a(b|c){1,1}d - abd abd b
|
||||
a(b|c){1,1}d - acd acd c
|
||||
a(b|c){1,2}d - abd abd b
|
||||
a(b|c){1,2}d - abcd abcd c
|
||||
a(b|c){1,}d - abd abd b
|
||||
a(b|c){1,}d - abcd abcd c
|
||||
a(b|c){2,2}d - acbd acbd b
|
||||
a(b|c){2,2}d - abcd abcd c
|
||||
a(b|c){2,4}d - abcd abcd c
|
||||
a(b|c){2,4}d - abcbd abcbd b
|
||||
a(b|c){2,4}d - abcbcd abcbcd c
|
||||
a(b|c){2,}d - abcd abcd c
|
||||
a(b|c){2,}d - abcbd abcbd b
|
||||
a(b+|((c)*))+d - abd abd b,-,-
|
||||
a(b+|((c)*))+d - abcd abcd c,c,c
|
||||
|
||||
# check out the STARTEND option
|
||||
[abc] &# a(b)c b
|
||||
[abc] &# a(d)c
|
||||
[abc] &# a(bc)d b
|
||||
[abc] &# a(dc)d c
|
||||
. &# a()c
|
||||
b.*c &# b(bc)c bc
|
||||
b.* &# b(bc)c bc
|
||||
.*c &# b(bc)c bc
|
||||
|
||||
# plain strings, with the NOSPEC flag
|
||||
abc m abc abc
|
||||
abc m xabcy abc
|
||||
abc m xyz
|
||||
a*b m aba*b a*b
|
||||
a*b m ab
|
||||
"" mC EMPTY
|
||||
|
||||
# cases involving NULs
|
||||
aZb & a a
|
||||
aZb &p a
|
||||
aZb &p# (aZb) aZb
|
||||
aZ*b &p# (ab) ab
|
||||
a.b &# (aZb) aZb
|
||||
a.* &# (aZb)c aZb
|
||||
|
||||
# word boundaries (ick)
|
||||
[[:<:]]a & a a
|
||||
[[:<:]]a & ba
|
||||
[[:<:]]a & -a a
|
||||
a[[:>:]] & a a
|
||||
a[[:>:]] & ab
|
||||
a[[:>:]] & a- a
|
||||
[[:<:]]a.c[[:>:]] & axcd-dayc-dazce-abc abc
|
||||
[[:<:]]a.c[[:>:]] & axcd-dayc-dazce-abc-q abc
|
||||
[[:<:]]a.c[[:>:]] & axc-dayc-dazce-abc axc
|
||||
[[:<:]]b.c[[:>:]] & a_bxc-byc_d-bzc-q bzc
|
||||
[[:<:]].x..[[:>:]] & y_xa_-_xb_y-_xc_-axdc _xc_
|
||||
[[:<:]]a_b[[:>:]] & x_a_b
|
||||
|
||||
# past problems, and suspected problems
|
||||
(A[1])|(A[2])|(A[3])|(A[4])|(A[5])|(A[6])|(A[7])|(A[8])|(A[9])|(A[A]) - A1 A1
|
||||
abcdefghijklmnop i abcdefghijklmnop abcdefghijklmnop
|
||||
abcdefghijklmnopqrstuv i abcdefghijklmnopqrstuv abcdefghijklmnopqrstuv
|
||||
(ALAK)|(ALT[AB])|(CC[123]1)|(CM[123]1)|(GAMC)|(LC[23][EO ])|(SEM[1234])|(SL[ES][12])|(SLWW)|(SLF )|(SLDT)|(VWH[12])|(WH[34][EW])|(WP1[ESN]) - CC11 CC11
|
||||
CC[13]1|a{21}[23][EO][123][Es][12]a{15}aa[34][EW]aaaaaaa[X]a - CC11 CC11
|
||||
Char \([a-z0-9_]*\)\[.* b Char xyz[k Char xyz[k xyz
|
||||
a?b - ab ab
|
||||
-\{0,1\}[0-9]*$ b -5 -5
|
||||
a*a*a*a*a*a*a* & aaaaaa aaaaaa
|
||||
@@ -1,61 +0,0 @@
|
||||
/* Test for re_match with non-zero start.
|
||||
Copyright (C) 2002 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
Contributed by Jakub Jelinek <jakub@redhat.com>, 2002.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
The GNU C Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with the GNU C Library; if not, write to the Free
|
||||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA. */
|
||||
|
||||
#include <locale.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <regex.h>
|
||||
|
||||
int
|
||||
main (void)
|
||||
{
|
||||
struct re_pattern_buffer regex;
|
||||
struct re_registers regs;
|
||||
const char *s;
|
||||
int match;
|
||||
int result = 0;
|
||||
|
||||
regs.num_regs = 1;
|
||||
memset (®ex, '\0', sizeof (regex));
|
||||
s = re_compile_pattern ("[abc]*d", 7, ®ex);
|
||||
if (s != NULL)
|
||||
{
|
||||
puts ("re_compile_pattern return non-NULL value");
|
||||
result = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
match = re_match (®ex, "foacabdxy", 9, 2, ®s);
|
||||
if (match != 5)
|
||||
{
|
||||
printf ("re_match returned %d, expected 5\n", match);
|
||||
result = 1;
|
||||
}
|
||||
else if (regs.start[0] != 2 || regs.end[0] != 7)
|
||||
{
|
||||
printf ("re_match returned %d..%d, expected 2..7\n",
|
||||
regs.start[0], regs.end[0]);
|
||||
result = 1;
|
||||
}
|
||||
puts (" -> OK");
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
@@ -1,135 +0,0 @@
|
||||
/* Regular expression tests.
|
||||
Copyright (C) 2002, 2003 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
Contributed by Jakub Jelinek <jakub@redhat.com>, 2002.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
The GNU C Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with the GNU C Library; if not, write to the Free
|
||||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA. */
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <mcheck.h>
|
||||
#include <regex.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
/* Tests supposed to match. */
|
||||
struct
|
||||
{
|
||||
const char *pattern;
|
||||
const char *string;
|
||||
int flags, nmatch;
|
||||
regmatch_t rm[5];
|
||||
} tests[] = {
|
||||
/* Test for newline handling in regex. */
|
||||
{ "[^~]*~", "\nx~y", 0, 2, { { 0, 3 }, { -1, -1 } } },
|
||||
/* Other tests. */
|
||||
{ "a(.*)b", "a b", REG_EXTENDED, 2, { { 0, 3 }, { 1, 2 } } },
|
||||
{ ".*|\\([KIO]\\)\\([^|]*\\).*|?[KIO]", "10~.~|P|K0|I10|O16|?KSb", 0, 3,
|
||||
{ { 0, 21 }, { 15, 16 }, { 16, 18 } } },
|
||||
{ ".*|\\([KIO]\\)\\([^|]*\\).*|?\\1", "10~.~|P|K0|I10|O16|?KSb", 0, 3,
|
||||
{ { 0, 21 }, { 8, 9 }, { 9, 10 } } },
|
||||
{ "^\\(a*\\)\\1\\{9\\}\\(a\\{0,9\\}\\)\\([0-9]*;.*[^a]\\2\\([0-9]\\)\\)",
|
||||
"a1;;0a1aa2aaa3aaaa4aaaaa5aaaaaa6aaaaaaa7aaaaaaaa8aaaaaaaaa9aa2aa1a0", 0,
|
||||
5, { { 0, 67 }, { 0, 0 }, { 0, 1 }, { 1, 67 }, { 66, 67 } } },
|
||||
/* Test for BRE expression anchoring. POSIX says just that this may match;
|
||||
in glibc regex it always matched, so avoid changing it. */
|
||||
{ "\\(^\\|foo\\)bar", "bar", 0, 2, { { 0, 3 }, { -1, -1 } } },
|
||||
{ "\\(foo\\|^\\)bar", "bar", 0, 2, { { 0, 3 }, { -1, -1 } } },
|
||||
/* In ERE this must be treated as an anchor. */
|
||||
{ "(^|foo)bar", "bar", REG_EXTENDED, 2, { { 0, 3 }, { -1, -1 } } },
|
||||
{ "(foo|^)bar", "bar", REG_EXTENDED, 2, { { 0, 3 }, { -1, -1 } } },
|
||||
/* Here ^ cannot be treated as an anchor according to POSIX. */
|
||||
{ "(^|foo)bar", "(^|foo)bar", 0, 2, { { 0, 10 }, { -1, -1 } } },
|
||||
{ "(foo|^)bar", "(foo|^)bar", 0, 2, { { 0, 10 }, { -1, -1 } } },
|
||||
/* More tests on backreferences. */
|
||||
{ "()\\1", "x", REG_EXTENDED, 2, { { 0, 0 }, { 0, 0 } } },
|
||||
{ "()x\\1", "x", REG_EXTENDED, 2, { { 0, 1 }, { 0, 0 } } },
|
||||
{ "()\\1*\\1*", "", REG_EXTENDED, 2, { { 0, 0 }, { 0, 0 } } },
|
||||
{ "([0-9]).*\\1(a*)", "7;7a6", REG_EXTENDED, 3, { { 0, 4 }, { 0, 1 }, { 3, 4 } } },
|
||||
{ "([0-9]).*\\1(a*)", "7;7a", REG_EXTENDED, 3, { { 0, 4 }, { 0, 1 }, { 3, 4 } } },
|
||||
{ "(b)()c\\1", "bcb", REG_EXTENDED, 3, { { 0, 3 }, { 0, 1 }, { 1, 1 } } },
|
||||
{ "()(b)c\\2", "bcb", REG_EXTENDED, 3, { { 0, 3 }, { 0, 0 }, { 0, 1 } } },
|
||||
{ "a(b)()c\\1", "abcb", REG_EXTENDED, 3, { { 0, 4 }, { 1, 2 }, { 2, 2 } } },
|
||||
{ "a()(b)c\\2", "abcb", REG_EXTENDED, 3, { { 0, 4 }, { 1, 1 }, { 1, 2 } } },
|
||||
{ "()(b)\\1c\\2", "bcb", REG_EXTENDED, 3, { { 0, 3 }, { 0, 0 }, { 0, 1 } } },
|
||||
{ "(b())\\2\\1", "bbbb", REG_EXTENDED, 3, { { 0, 2 }, { 0, 1 }, { 1, 1 } } },
|
||||
{ "a()(b)\\1c\\2", "abcb", REG_EXTENDED, 3, { { 0, 4 }, { 1, 1 }, { 1, 2 } } },
|
||||
{ "a()d(b)\\1c\\2", "adbcb", REG_EXTENDED, 3, { { 0, 5 }, { 1, 1 }, { 2, 3 } } },
|
||||
{ "a(b())\\2\\1", "abbbb", REG_EXTENDED, 3, { { 0, 3 }, { 1, 2 }, { 2, 2 } } },
|
||||
{ "(bb())\\2\\1", "bbbb", REG_EXTENDED, 3, { { 0, 4 }, { 0, 2 }, { 2, 2 } } },
|
||||
{ "^(.?)(.?)(.?)(.?)(.?).?\\5\\4\\3\\2\\1$",
|
||||
"level", REG_NOSUB | REG_EXTENDED, 0, { { -1, -1 } } },
|
||||
{ "^(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.).?\\9\\8\\7\\6\\5\\4\\3\\2\\1$|^.?$",
|
||||
"level", REG_NOSUB | REG_EXTENDED, 0, { { -1, -1 } } },
|
||||
{ "^(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.).?\\9\\8\\7\\6\\5\\4\\3\\2\\1$|^.?$",
|
||||
"abcdedcba", REG_EXTENDED, 1, { { 0, 9 } } },
|
||||
#if 0
|
||||
/* XXX Not used since they fail so far. */
|
||||
{ "^(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.).?\\9\\8\\7\\6\\5\\4\\3\\2\\1$|^.?$",
|
||||
"ababababa", REG_EXTENDED, 1, { { 0, 9 } } },
|
||||
{ "^(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?).?\\9\\8\\7\\6\\5\\4\\3\\2\\1$",
|
||||
"level", REG_NOSUB | REG_EXTENDED, 0, { { -1, -1 } } },
|
||||
{ "^(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?).?\\9\\8\\7\\6\\5\\4\\3\\2\\1$",
|
||||
"ababababa", REG_EXTENDED, 1, { { 0, 9 } } },
|
||||
#endif
|
||||
};
|
||||
|
||||
int
|
||||
main (void)
|
||||
{
|
||||
regex_t re;
|
||||
regmatch_t rm[5];
|
||||
size_t i;
|
||||
int n, ret = 0;
|
||||
|
||||
mtrace ();
|
||||
|
||||
for (i = 0; i < sizeof (tests) / sizeof (tests[0]); ++i)
|
||||
{
|
||||
n = regcomp (&re, tests[i].pattern, tests[i].flags);
|
||||
if (n != 0)
|
||||
{
|
||||
char buf[500];
|
||||
regerror (n, &re, buf, sizeof (buf));
|
||||
printf ("%s: regcomp %zd failed: %s\n", tests[i].pattern, i, buf);
|
||||
ret = 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (regexec (&re, tests[i].string, tests[i].nmatch, rm, 0))
|
||||
{
|
||||
printf ("%s: regexec %zd failed\n", tests[i].pattern, i);
|
||||
ret = 1;
|
||||
regfree (&re);
|
||||
continue;
|
||||
}
|
||||
|
||||
for (n = 0; n < tests[i].nmatch; ++n)
|
||||
if (rm[n].rm_so != tests[i].rm[n].rm_so
|
||||
|| rm[n].rm_eo != tests[i].rm[n].rm_eo)
|
||||
{
|
||||
if (tests[i].rm[n].rm_so == -1 && tests[i].rm[n].rm_eo == -1)
|
||||
break;
|
||||
printf ("%s: regexec %zd match failure rm[%d] %d..%d\n",
|
||||
tests[i].pattern, i, n, rm[n].rm_so, rm[n].rm_eo);
|
||||
ret = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
regfree (&re);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -1,73 +0,0 @@
|
||||
/* Regular expression tests.
|
||||
Copyright (C) 2002, 2003 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
Contributed by Jakub Jelinek <jakub@redhat.com>, 2002.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
The GNU C Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with the GNU C Library; if not, write to the Free
|
||||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA. */
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <mcheck.h>
|
||||
#include <regex.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
/* Tests supposed to not match. */
|
||||
struct
|
||||
{
|
||||
const char *pattern;
|
||||
const char *string;
|
||||
int flags, nmatch;
|
||||
} tests[] = {
|
||||
{ "^<\\([^~]*\\)\\([^~]\\)[^~]*~\\1\\(.\\).*|=.*\\3.*\\2",
|
||||
"<,.8~2,~so-|=-~.0,123456789<><", REG_NOSUB, 0 },
|
||||
/* In ERE, all carets must be treated as anchors. */
|
||||
{ "a^b", "a^b", REG_EXTENDED, 0 }
|
||||
};
|
||||
|
||||
int
|
||||
main (void)
|
||||
{
|
||||
regex_t re;
|
||||
regmatch_t rm[4];
|
||||
size_t i;
|
||||
int n, ret = 0;
|
||||
|
||||
mtrace ();
|
||||
|
||||
for (i = 0; i < sizeof (tests) / sizeof (tests[0]); ++i)
|
||||
{
|
||||
n = regcomp (&re, tests[i].pattern, tests[i].flags);
|
||||
if (n != 0)
|
||||
{
|
||||
char buf[500];
|
||||
regerror (n, &re, buf, sizeof (buf));
|
||||
printf ("regcomp %zd failed: %s\n", i, buf);
|
||||
ret = 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (! regexec (&re, tests[i].string, tests[i].nmatch,
|
||||
tests[i].nmatch ? rm : NULL, 0))
|
||||
{
|
||||
printf ("regexec %zd incorrectly matched\n", i);
|
||||
ret = 1;
|
||||
}
|
||||
|
||||
regfree (&re);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -1,103 +0,0 @@
|
||||
/* Regular expression tests.
|
||||
Copyright (C) 2002 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
Contributed by Isamu Hasegawa <isamu@yamato.ibm.com>, 2002.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
The GNU C Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with the GNU C Library; if not, write to the Free
|
||||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA. */
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <mcheck.h>
|
||||
#include <regex.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
static struct
|
||||
{
|
||||
int syntax;
|
||||
const char *pattern;
|
||||
const char *string;
|
||||
int start;
|
||||
} tests[] = {
|
||||
{RE_BACKSLASH_ESCAPE_IN_LISTS, "[0\\-9]", "1", -1}, /* It should not match. */
|
||||
{RE_BACKSLASH_ESCAPE_IN_LISTS, "[0\\-9]", "-", 0}, /* It should match. */
|
||||
{RE_SYNTAX_POSIX_BASIC, "s1\n.*\ns3", "s1\ns2\ns3", 0},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{0}c", "ac", 0},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{0}c", "abc", -1},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{0}c", "abbc", -1},
|
||||
/* Nested duplication. */
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{1}{1}c", "ac", -1},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{1}{1}c", "abc", 0},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{1}{1}c", "abbc", -1},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{2}{2}c", "ac", -1},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{2}{2}c", "abbc", -1},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{2}{2}c", "abbbbc", 0},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{2}{2}c", "abbbbbc", -1},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{0}{1}c", "ac", 0},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{0}{1}c", "abc", -1},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{0}{1}c", "abbc", -1},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{1}{0}c", "ac", 0},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{1}{0}c", "abc", -1},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{1}{0}c", "abbc", -1},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{0}*c", "ac", 0},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{0}*c", "abc", -1},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{0}*c", "abbc", -1},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{0}?c", "ac", 0},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{0}?c", "abc", -1},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{0}?c", "abbc", -1},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{0}+c", "ac", 0},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{0}+c", "abc", -1},
|
||||
{RE_SYNTAX_POSIX_EXTENDED, "ab{0}+c", "abbc", -1},
|
||||
};
|
||||
|
||||
int
|
||||
main (void)
|
||||
{
|
||||
struct re_pattern_buffer regbuf;
|
||||
const char *err;
|
||||
size_t i;
|
||||
int ret = 0;
|
||||
|
||||
mtrace ();
|
||||
|
||||
for (i = 0; i < sizeof (tests) / sizeof (tests[0]); ++i)
|
||||
{
|
||||
int start;
|
||||
re_set_syntax (tests[i].syntax);
|
||||
memset (®buf, '\0', sizeof (regbuf));
|
||||
err = re_compile_pattern (tests[i].pattern, strlen (tests[i].pattern),
|
||||
®buf);
|
||||
if (err != NULL)
|
||||
{
|
||||
printf ("re_compile_pattern failed: %s\n", err);
|
||||
ret = 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
start = re_search (®buf, tests[i].string, strlen (tests[i].string),
|
||||
0, strlen (tests[i].string), NULL);
|
||||
if (start != tests[i].start)
|
||||
{
|
||||
printf ("re_search failed %d\n", start);
|
||||
ret = 1;
|
||||
regfree (®buf);
|
||||
continue;
|
||||
}
|
||||
regfree (®buf);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -1,54 +0,0 @@
|
||||
/* Tests re_comp and re_exec.
|
||||
Copyright (C) 2002 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
Contributed by Isamu Hasegawa <isamu@yamato.ibm.com>, 2002.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
The GNU C Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with the GNU C Library; if not, write to the Free
|
||||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA. */
|
||||
|
||||
#define _REGEX_RE_COMP
|
||||
#include <sys/types.h>
|
||||
#include <mcheck.h>
|
||||
#include <regex.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
int
|
||||
main (void)
|
||||
{
|
||||
const char *err;
|
||||
size_t i;
|
||||
int ret = 0;
|
||||
|
||||
mtrace ();
|
||||
|
||||
for (i = 0; i < 100; ++i)
|
||||
{
|
||||
err = re_comp ("a t.st");
|
||||
if (err)
|
||||
{
|
||||
printf ("re_comp failed: %s\n", err);
|
||||
ret = 1;
|
||||
}
|
||||
|
||||
if (! re_exec ("This is a test."))
|
||||
{
|
||||
printf ("re_exec failed\n");
|
||||
ret = 1;
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -1,47 +0,0 @@
|
||||
/* Test for memory/CPU leak in regcomp. */
|
||||
|
||||
#include <error.h>
|
||||
#include <sys/resource.h>
|
||||
#include <sys/types.h>
|
||||
#include <regex.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#define TEST_DATA_LIMIT (32 << 20)
|
||||
|
||||
int
|
||||
main ()
|
||||
{
|
||||
#ifdef RLIMIT_DATA
|
||||
regex_t re;
|
||||
int reerr;
|
||||
|
||||
/* Try to avoid eating all memory if a test leaks. */
|
||||
struct rlimit data_limit;
|
||||
if (getrlimit (RLIMIT_DATA, &data_limit) == 0)
|
||||
{
|
||||
if ((rlim_t) TEST_DATA_LIMIT > data_limit.rlim_max)
|
||||
data_limit.rlim_cur = data_limit.rlim_max;
|
||||
else if (data_limit.rlim_cur > (rlim_t) TEST_DATA_LIMIT)
|
||||
data_limit.rlim_cur = (rlim_t) TEST_DATA_LIMIT;
|
||||
if (setrlimit (RLIMIT_DATA, &data_limit) < 0)
|
||||
perror ("setrlimit: RLIMIT_DATA");
|
||||
}
|
||||
else
|
||||
perror ("getrlimit: RLIMIT_DATA");
|
||||
|
||||
reerr = regcomp (&re, "^6?3?[25]?5?[14]*[25]*[69]*+[58]*87?4?$",
|
||||
REG_EXTENDED | REG_NOSUB);
|
||||
if (reerr != 0)
|
||||
{
|
||||
char buf[100];
|
||||
regerror (reerr, &re, buf, sizeof buf);
|
||||
printf ("regerror %s\n", buf);
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
#else
|
||||
return 77;
|
||||
#endif
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
/* Test re_compile_pattern error messages. */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <regex.h>
|
||||
|
||||
int
|
||||
main (void)
|
||||
{
|
||||
struct re_pattern_buffer re;
|
||||
const char *s;
|
||||
int ret = 0;
|
||||
|
||||
re_set_syntax (RE_SYNTAX_POSIX_EGREP);
|
||||
memset (&re, 0, sizeof (re));
|
||||
s = re_compile_pattern ("[[.invalid_collating_symbol.]]", 30, &re);
|
||||
if (s == NULL || strcmp (s, "Invalid collation character"))
|
||||
{
|
||||
printf ("re_compile_pattern returned %s\n", s);
|
||||
ret = 1;
|
||||
}
|
||||
s = re_compile_pattern ("[[=invalid_equivalence_class=]]", 31, &re);
|
||||
if (s == NULL || strcmp (s, "Invalid collation character"))
|
||||
{
|
||||
printf ("re_compile_pattern returned %s\n", s);
|
||||
ret = 1;
|
||||
}
|
||||
s = re_compile_pattern ("[[:invalid_character_class:]]", 29, &re);
|
||||
if (s == NULL || strcmp (s, "Invalid character class name"))
|
||||
{
|
||||
printf ("re_compile_pattern returned %s\n", s);
|
||||
ret = 1;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
@@ -1,45 +0,0 @@
|
||||
/* Test for memory leaks in regcomp.
|
||||
Copyright (C) 2003 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
Contributed by Jakub Jelinek <jakub@redhat.com>, 2003.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
The GNU C Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with the GNU C Library; if not, write to the Free
|
||||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA. */
|
||||
|
||||
#include <mcheck.h>
|
||||
#include <regex.h>
|
||||
#include <stdio.h>
|
||||
|
||||
int main (void)
|
||||
{
|
||||
regex_t re;
|
||||
int i;
|
||||
int ret = 0;
|
||||
|
||||
mtrace ();
|
||||
|
||||
for (i = 0; i < 32; ++i)
|
||||
{
|
||||
if (regcomp (&re, "X-.+:.+Y=\".*\\.(A|B|C|D|E|F|G|H|I",
|
||||
REG_EXTENDED | REG_ICASE) == 0)
|
||||
{
|
||||
puts ("regcomp unexpectedly succeeded");
|
||||
ret = 1;
|
||||
}
|
||||
else
|
||||
regfree (&re);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
@@ -1,92 +0,0 @@
|
||||
/* Test for regs allocation in re_search and re_match.
|
||||
Copyright (C) 2002 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
Contributed by Stepan Kasal <kasal@math.cas.cz>, 2002.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
The GNU C Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with the GNU C Library; if not, write to the Free
|
||||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA. */
|
||||
|
||||
#include <locale.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/types.h>
|
||||
#include <regex.h>
|
||||
|
||||
|
||||
int
|
||||
main (void)
|
||||
{
|
||||
struct re_pattern_buffer regex;
|
||||
struct re_registers regs;
|
||||
const char *s;
|
||||
int match, n;
|
||||
int result = 0;
|
||||
|
||||
memset (®ex, '\0', sizeof (regex));
|
||||
regs.start = regs.end = NULL;
|
||||
regs.num_regs = 0;
|
||||
s = re_compile_pattern ("a", 1, ®ex);
|
||||
if (s != NULL)
|
||||
{
|
||||
puts ("failed to compile pattern \"a\"");
|
||||
result = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
match = re_search (®ex, "baobab", 6, 0, 6, ®s);
|
||||
n = 1;
|
||||
if (match != 1)
|
||||
{
|
||||
printf ("re_search returned %d, expected 1\n", match);
|
||||
result = 1;
|
||||
}
|
||||
else if (regs.num_regs <= n || regs.start[n] != -1 || regs.end[n] != -1)
|
||||
{
|
||||
puts ("re_search failed to fill the -1 sentinel");
|
||||
result = 1;
|
||||
}
|
||||
}
|
||||
|
||||
free (regex.buffer);
|
||||
memset (®ex, '\0', sizeof (regex));
|
||||
|
||||
s = re_compile_pattern ("\\(\\(\\(a\\)\\)\\)", 13, ®ex);
|
||||
if (s != NULL)
|
||||
{
|
||||
puts ("failed to compile pattern /\\(\\(\\(a\\)\\)\\)/");
|
||||
result = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
match = re_match (®ex, "apl", 3, 0, ®s);
|
||||
n = 4;
|
||||
if (match != 1)
|
||||
{
|
||||
printf ("re_match returned %d, expected 1\n", match);
|
||||
result = 1;
|
||||
}
|
||||
else if (regs.num_regs <= n || regs.start[n] != -1 || regs.end[n] != -1)
|
||||
{
|
||||
puts ("re_match failed to fill the -1 sentinel");
|
||||
result = 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (result == 0)
|
||||
puts (" -> OK");
|
||||
|
||||
return result;
|
||||
}
|
||||
@@ -1,84 +0,0 @@
|
||||
/* Test for the STOP parameter of re_match_2 and re_search_2.
|
||||
Copyright (C) 2002 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
Contributed by Stepan Kasal <kasal@math.cas.cz>, 2002.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
The GNU C Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with the GNU C Library; if not, write to the Free
|
||||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA. */
|
||||
|
||||
#include <locale.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/types.h>
|
||||
#include <regex.h>
|
||||
|
||||
|
||||
int
|
||||
main (void)
|
||||
{
|
||||
struct re_pattern_buffer regex;
|
||||
const char *s;
|
||||
int match[4];
|
||||
|
||||
memset (®ex, '\0', sizeof (regex));
|
||||
|
||||
s = re_compile_pattern ("xy$", 3, ®ex);
|
||||
if (s != NULL)
|
||||
{
|
||||
puts ("failed to compile pattern \"xy$\"");
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
match[0] = re_match_2(®ex,"xyz",3,NULL,0,0,NULL,2);
|
||||
|
||||
free (regex.buffer);
|
||||
memset (®ex, '\0', sizeof (regex));
|
||||
|
||||
s = re_compile_pattern ("xy\\>", 4, ®ex);
|
||||
if (s != NULL)
|
||||
{
|
||||
puts ("failed to compile pattern \"xy\\>\"");
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
match[1] = re_search_2(®ex,"xyz",3,NULL,0,0,2,NULL,2);
|
||||
|
||||
free (regex.buffer);
|
||||
memset (®ex, '\0', sizeof (regex));
|
||||
|
||||
s = re_compile_pattern ("xy \\<", 5, ®ex);
|
||||
if (s != NULL)
|
||||
{
|
||||
puts ("failed to compile pattern \"xy \\<\"");
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
match[2] = re_match_2(®ex,"xy ",4,NULL,0,0,NULL,3);
|
||||
match[3] = re_match_2(®ex,"xy z",4,NULL,0,0,NULL,3);
|
||||
}
|
||||
|
||||
if (match[0] != -1 || match[1] != -1 || match[2] != -1 || match[3] != 3)
|
||||
{
|
||||
printf ("re_{match,search}_2 returned %d,%d,%d,%d, expected -1,-1,-1,3\n",
|
||||
match[0], match[1], match[2], match[3]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
puts (" -> OK");
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,67 +0,0 @@
|
||||
/* Test for memory handling in regex.
|
||||
Copyright (C) 2002 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
Contributed by Ulrich Drepper <drepper@redhat.com>, 2001.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
The GNU C Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with the GNU C Library; if not, write to the Free
|
||||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA. */
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <mcheck.h>
|
||||
#include <regex.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
|
||||
static const char text[] = "#! /bin/sh";
|
||||
|
||||
int
|
||||
main (void)
|
||||
{
|
||||
regex_t re;
|
||||
regmatch_t rm[2];
|
||||
int n;
|
||||
|
||||
mtrace ();
|
||||
|
||||
n = regcomp (&re, "^#! */.*/(k|ba||pdk|z)sh", REG_EXTENDED);
|
||||
if (n != 0)
|
||||
{
|
||||
char buf[500];
|
||||
regerror (n, &re, buf, sizeof (buf));
|
||||
printf ("regcomp failed: %s\n", buf);
|
||||
exit (1);
|
||||
}
|
||||
|
||||
for (n = 0; n < 20; ++n)
|
||||
{
|
||||
if (regexec (&re, text, 2, rm, 0))
|
||||
{
|
||||
puts ("regexec failed");
|
||||
exit (2);
|
||||
}
|
||||
if (rm[0].rm_so != 0 || rm[0].rm_eo != 10
|
||||
|| rm[1].rm_so != 8 || rm[1].rm_eo != 8)
|
||||
{
|
||||
printf ("regexec match failure: %d %d %d %d\n",
|
||||
rm[0].rm_so, rm[0].rm_eo, rm[1].rm_so, rm[1].rm_eo);
|
||||
exit (3);
|
||||
}
|
||||
}
|
||||
|
||||
regfree (&re);
|
||||
|
||||
return 0;
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
+1964
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,928 @@
|
||||
/the quick brown fox/
|
||||
the quick brown fox
|
||||
What do you know about the quick brown fox?
|
||||
*** Failers
|
||||
The quick brown FOX
|
||||
What do you know about THE QUICK BROWN FOX?
|
||||
|
||||
/The quick brown fox/i
|
||||
the quick brown fox
|
||||
The quick brown FOX
|
||||
What do you know about the quick brown fox?
|
||||
What do you know about THE QUICK BROWN FOX?
|
||||
|
||||
/abcd\t\n\r\f\a\e\o071\x3b\$\\?caxyz/
|
||||
abcd\t\n\r\f\a\e9;\$\\?caxyz
|
||||
|
||||
/a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/x
|
||||
abxyzpqrrrabbxyyyypqAzz
|
||||
abxyzpqrrrabbxyyyypqAzz
|
||||
aabxyzpqrrrabbxyyyypqAzz
|
||||
aaabxyzpqrrrabbxyyyypqAzz
|
||||
aaaabxyzpqrrrabbxyyyypqAzz
|
||||
abcxyzpqrrrabbxyyyypqAzz
|
||||
aabcxyzpqrrrabbxyyyypqAzz
|
||||
aaabcxyzpqrrrabbxyyyypAzz
|
||||
aaabcxyzpqrrrabbxyyyypqAzz
|
||||
aaabcxyzpqrrrabbxyyyypqqAzz
|
||||
aaabcxyzpqrrrabbxyyyypqqqAzz
|
||||
aaabcxyzpqrrrabbxyyyypqqqqAzz
|
||||
aaabcxyzpqrrrabbxyyyypqqqqqAzz
|
||||
aaabcxyzpqrrrabbxyyyypqqqqqqAzz
|
||||
aaaabcxyzpqrrrabbxyyyypqAzz
|
||||
abxyzzpqrrrabbxyyyypqAzz
|
||||
aabxyzzzpqrrrabbxyyyypqAzz
|
||||
aaabxyzzzzpqrrrabbxyyyypqAzz
|
||||
aaaabxyzzzzpqrrrabbxyyyypqAzz
|
||||
abcxyzzpqrrrabbxyyyypqAzz
|
||||
aabcxyzzzpqrrrabbxyyyypqAzz
|
||||
aaabcxyzzzzpqrrrabbxyyyypqAzz
|
||||
aaaabcxyzzzzpqrrrabbxyyyypqAzz
|
||||
aaaabcxyzzzzpqrrrabbbxyyyypqAzz
|
||||
aaaabcxyzzzzpqrrrabbbxyyyyypqAzz
|
||||
aaabcxyzpqrrrabbxyyyypABzz
|
||||
aaabcxyzpqrrrabbxyyyypABBzz
|
||||
>>>aaabxyzpqrrrabbxyyyypqAzz
|
||||
>aaaabxyzpqrrrabbxyyyypqAzz
|
||||
>>>>abcxyzpqrrrabbxyyyypqAzz
|
||||
*** Failers
|
||||
abxyzpqrrabbxyyyypqAzz
|
||||
abxyzpqrrrrabbxyyyypqAzz
|
||||
abxyzpqrrrabxyyyypqAzz
|
||||
aaaabcxyzzzzpqrrrabbbxyyyyyypqAzz
|
||||
aaaabcxyzzzzpqrrrabbbxyyypqAzz
|
||||
aaabcxyzpqrrrabbxyyyypqqqqqqqAzz
|
||||
|
||||
/^\(abc\)\{1,2\}zz/
|
||||
abczz
|
||||
abcabczz
|
||||
*** Failers
|
||||
zz
|
||||
abcabcabczz
|
||||
>>abczz
|
||||
|
||||
/^(b+|a){1,2}c/x
|
||||
bc
|
||||
bbc
|
||||
bbbc
|
||||
bac
|
||||
bbac
|
||||
aac
|
||||
abbbbbbbbbbbc
|
||||
bbbbbbbbbbbac
|
||||
*** Failers
|
||||
aaac
|
||||
abbbbbbbbbbbac
|
||||
|
||||
/^\(b\+\|a\)\{1,2\}c/
|
||||
bc
|
||||
bbc
|
||||
bbbc
|
||||
bac
|
||||
bbac
|
||||
aac
|
||||
abbbbbbbbbbbc
|
||||
bbbbbbbbbbbac
|
||||
*** Failers
|
||||
aaac
|
||||
abbbbbbbbbbbac
|
||||
|
||||
/^(b+|a){1,2}?bc/x
|
||||
bbc
|
||||
|
||||
/^ba*\(ba\)\?bc/
|
||||
babc
|
||||
bbabc
|
||||
bababc
|
||||
*** Failers
|
||||
bababbc
|
||||
babababc
|
||||
|
||||
# Under Perl rules, babc matches as this:
|
||||
# first repetition of (ba|b*) sets subexpression 1 to ba
|
||||
# second repetition of (ba|b*) sets subexpression 1 to the empty string
|
||||
# then bc matches
|
||||
#
|
||||
# Under Posix rules, however, "a subexpression repeated by an
|
||||
# asterisk ('*') _or an interval expression_ shall not match a
|
||||
# null expression unless this is the only match for the
|
||||
# repetition or it is necessary to satisfy the exact or
|
||||
# minimum number of occurrences for the interval expression."
|
||||
# This goes against the general rule for greedy matching, anyway
|
||||
# it matches as this:
|
||||
# first repetition of (ba|b*) sets subexpression 1 to ba
|
||||
# second repetition of (ba|b*) is void and ignored
|
||||
# bc matches
|
||||
/^(ba|b*){1,2}bc/x
|
||||
babc
|
||||
bbabc
|
||||
babbbc
|
||||
*** Failers
|
||||
bababbc
|
||||
babababc
|
||||
|
||||
/^\ca\cA\c[\c{\c:/x
|
||||
\x01\x01\e;z
|
||||
|
||||
/^[]cde]/
|
||||
]thing
|
||||
cthing
|
||||
dthing
|
||||
ething
|
||||
*** Failers
|
||||
athing
|
||||
fthing
|
||||
|
||||
/^[^]cde]/
|
||||
athing
|
||||
fthing
|
||||
*** Failers
|
||||
]thing
|
||||
cthing
|
||||
dthing
|
||||
ething
|
||||
|
||||
/^\�/
|
||||
�
|
||||
|
||||
/^ÿ/
|
||||
ÿ
|
||||
|
||||
/^[0-9]+$/x
|
||||
0
|
||||
1
|
||||
2
|
||||
3
|
||||
4
|
||||
5
|
||||
6
|
||||
7
|
||||
8
|
||||
9
|
||||
10
|
||||
100
|
||||
*** Failers
|
||||
abc
|
||||
|
||||
/^.*nter/x
|
||||
enter
|
||||
inter
|
||||
uponter
|
||||
|
||||
/b*c*b+/x
|
||||
bbbb
|
||||
|
||||
/^xxx[0-9]+$/x
|
||||
xxx0
|
||||
xxx1234
|
||||
*** Failers
|
||||
xxx
|
||||
|
||||
/^.+[0-9][0-9][0-9]$/x
|
||||
x123
|
||||
xx123
|
||||
123456
|
||||
*** Failers
|
||||
123
|
||||
x1234
|
||||
|
||||
/^.+[0-9][0-9][0-9]$/x
|
||||
x123
|
||||
xx123
|
||||
123456
|
||||
*** Failers
|
||||
123
|
||||
x1234
|
||||
|
||||
/^([^!]+)!(.+)=apquxz\.ixr\.zzz\.ac\.uk$/x
|
||||
abc!pqr=apquxz.ixr.zzz.ac.uk
|
||||
*** Failers
|
||||
!pqr=apquxz.ixr.zzz.ac.uk
|
||||
abc!=apquxz.ixr.zzz.ac.uk
|
||||
abc!pqr=apquxz:ixr.zzz.ac.uk
|
||||
abc!pqr=apquxz.ixr.zzz.ac.ukk
|
||||
|
||||
/:/
|
||||
Well, we need a colon: somewhere
|
||||
*** Failers
|
||||
Fail if we don't
|
||||
|
||||
/([0-9a-f:]+)$/xi
|
||||
0abc
|
||||
abc
|
||||
fed
|
||||
E
|
||||
::
|
||||
5f03:12C0::932e
|
||||
fed def
|
||||
Any old stuff
|
||||
*** Failers
|
||||
0zzz
|
||||
gzzz
|
||||
fed\x20
|
||||
Any old rubbish
|
||||
|
||||
/^.*\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$/x
|
||||
.1.2.3
|
||||
A.12.123.0
|
||||
*** Failers
|
||||
.1.2.3333
|
||||
1.2.3
|
||||
1234.2.3
|
||||
|
||||
/^([0-9]+)[ \t]+IN[ \t]+SOA[ \t]+([^ \t]+)[ \t]+([^ \t]+)[ \t]*\([ \t]*$/x
|
||||
1 IN SOA non-sp1 non-sp2(
|
||||
1 IN SOA non-sp1 non-sp2 (
|
||||
*** Failers
|
||||
1IN SOA non-sp1 non-sp2(
|
||||
|
||||
/^[a-zA-Z0-9][a-zA-Z0-9\-]*(\.[a-zA-Z0-9][a-zA-z0-9\-]*)*\.$/x
|
||||
a.
|
||||
Z.
|
||||
2.
|
||||
ab-c.pq-r.
|
||||
sxk.zzz.ac.uk.
|
||||
x-.y-.
|
||||
*** Failers
|
||||
-abc.peq.
|
||||
|
||||
/^[0-9a-f](\.[0-9a-f])*$/xi
|
||||
a.b.c.d
|
||||
A.B.C.D
|
||||
a.b.c.1.2.3.C
|
||||
|
||||
/^\".*\"[ \t]*(;.*)?$/x
|
||||
\"1234\"
|
||||
\"abcd\" ;
|
||||
\"\" ; rhubarb
|
||||
*** Failers
|
||||
\"1234\" : things
|
||||
|
||||
/^$/
|
||||
\
|
||||
*** Failers
|
||||
|
||||
/^(a(b(c)))(d(e(f)))(h(i(j)))(k(l(m)))$/x
|
||||
abcdefhijklm
|
||||
|
||||
/^[A-Za-z_][^A-Za-z_][ \t][^ \t][0-9][^0-9]\x08[\n][\c]][\o022]/x
|
||||
a+ Z0+\x08\n\x1d\x12
|
||||
|
||||
/^[.^\\$|()*+?{,}]\+/
|
||||
.^\$(*+)|{?,?}
|
||||
|
||||
/^a*\w/x
|
||||
z
|
||||
az
|
||||
aaaz
|
||||
a
|
||||
aa
|
||||
aaaa
|
||||
a+
|
||||
aa+
|
||||
|
||||
/^a*\w/
|
||||
z
|
||||
az
|
||||
aaaz
|
||||
a
|
||||
aa
|
||||
aaaa
|
||||
a+
|
||||
aa+
|
||||
|
||||
/^a+\w/x
|
||||
az
|
||||
aaaz
|
||||
aa
|
||||
aaaa
|
||||
aa+
|
||||
|
||||
/^a\+\w/
|
||||
az
|
||||
aaaz
|
||||
aa
|
||||
aaaa
|
||||
aa+
|
||||
|
||||
/^[0-9]{8}\w{2,}/x
|
||||
1234567890
|
||||
12345678ab
|
||||
12345678__
|
||||
*** Failers
|
||||
1234567
|
||||
|
||||
/^[aeiou0-9]{4,5}$/x
|
||||
uoie
|
||||
1234
|
||||
12345
|
||||
aaaaa
|
||||
*** Failers
|
||||
123456
|
||||
|
||||
/^[aeiou0-9]{4,5}/x
|
||||
uoie
|
||||
1234
|
||||
12345
|
||||
aaaaa
|
||||
123456
|
||||
|
||||
/\`(abc|def)=(\1){2,3}\'/x
|
||||
abc=abcabc
|
||||
def=defdefdef
|
||||
*** Failers
|
||||
abc=defdef
|
||||
|
||||
/(cat(a(ract|tonic)|erpillar)) \1()2(3)/x
|
||||
cataract cataract23
|
||||
catatonic catatonic23
|
||||
caterpillar caterpillar23
|
||||
|
||||
|
||||
/^From +([^ ]+) +[a-zA-Z][a-zA-Z][a-zA-Z] +[a-zA-Z][a-zA-Z][a-zA-Z] +[0-9]?[0-9] +[0-9][0-9]:[0-9][0-9]/x
|
||||
From abcd Mon Sep 01 12:33:02 1997
|
||||
|
||||
/^From[ \t]+[^ \t]+[ \t]+([a-zA-Z]{3}[ \t]+){2}[0-9]{1,2}[ \t]+[0-9][0-9]:[0-9][0-9]/x
|
||||
From abcd Mon Sep 01 12:33:02 1997
|
||||
From abcd Mon Sep 1 12:33:02 1997
|
||||
*** Failers
|
||||
From abcd Sep 01 12:33:02 1997
|
||||
|
||||
/^12.34/xs
|
||||
12\n34
|
||||
12\r34
|
||||
|
||||
/^(a)\1{2,3}(.)/x
|
||||
aaab
|
||||
aaaab
|
||||
aaaaab
|
||||
aaaaaab
|
||||
|
||||
/^[ab]{1,3}(ab*|b)/x
|
||||
aabbbbb
|
||||
|
||||
/^[ab]{1,3}(ab*|b)/x
|
||||
aabbbbb
|
||||
|
||||
/^[ab]{1,3}(ab*|b)/x
|
||||
aabbbbb
|
||||
|
||||
/^[ab]{1,3}(ab*|b)/x
|
||||
aabbbbb
|
||||
|
||||
/abc\o0def\o00pqr\o000xyz\o0000AB/x
|
||||
abc\0def\00pqr\000xyz\0000AB
|
||||
abc456 abc\0def\00pqr\000xyz\0000ABCDE
|
||||
|
||||
/abc\x0def\x00pqr\x000xyz\x0000AB/x
|
||||
abc\x0def\x00pqr\x000xyz\x0000AB
|
||||
abc456 abc\x0def\x00pqr\x000xyz\x0000ABCDE
|
||||
|
||||
/^[\o000-\o037]/
|
||||
\0A
|
||||
\01B
|
||||
\037C
|
||||
|
||||
/\o0*/
|
||||
\0\0\0\0
|
||||
|
||||
/A\x0{2,3}Z/x
|
||||
The A\x0\x0Z
|
||||
An A\0\x0\0Z
|
||||
*** Failers
|
||||
A\0Z
|
||||
A\0\x0\0\x0Z
|
||||
|
||||
/^(cow|)\1(bell)/x
|
||||
cowcowbell
|
||||
bell
|
||||
*** Failers
|
||||
cowbell
|
||||
|
||||
/^[ \t\n\r\f]/
|
||||
\040abc
|
||||
\x0cabc
|
||||
\nabc
|
||||
\rabc
|
||||
\tabc
|
||||
*** Failers
|
||||
abc
|
||||
|
||||
/^(a|)\1*b/x
|
||||
ab
|
||||
aaaab
|
||||
b
|
||||
*** Failers
|
||||
acb
|
||||
|
||||
/^(a|)\1+b/x
|
||||
aab
|
||||
aaaab
|
||||
b
|
||||
*** Failers
|
||||
ab
|
||||
|
||||
/^(a|)\1?b/x
|
||||
ab
|
||||
aab
|
||||
b
|
||||
*** Failers
|
||||
acb
|
||||
|
||||
/^(a|)\1{2}b/x
|
||||
aaab
|
||||
b
|
||||
*** Failers
|
||||
ab
|
||||
aab
|
||||
aaaab
|
||||
|
||||
/^(a|)\1{2,3}b/x
|
||||
aaab
|
||||
aaaab
|
||||
b
|
||||
*** Failers
|
||||
ab
|
||||
aab
|
||||
aaaaab
|
||||
|
||||
/ab{1,3}bc/x
|
||||
abbbbc
|
||||
abbbc
|
||||
abbc
|
||||
*** Failers
|
||||
abc
|
||||
abbbbbc
|
||||
|
||||
/([^.]*)\.([^:]*):[T ]+(.*)/x
|
||||
track1.title:TBlah blah blah
|
||||
|
||||
/([^.]*)\.([^:]*):[T ]+(.*)/xi
|
||||
track1.title:TBlah blah blah
|
||||
|
||||
/([^.]*)\.([^:]*):[t ]+(.*)/xi
|
||||
track1.title:TBlah blah blah
|
||||
|
||||
/^[W-c]+$/x
|
||||
WXY_^abc
|
||||
***Failers
|
||||
wxy
|
||||
|
||||
/^[W-c]+$/xi
|
||||
WXY_^abc
|
||||
wxy_^ABC
|
||||
|
||||
/^[\x3f-\x5F]+$/xi
|
||||
WXY_^abc
|
||||
wxy_^ABC
|
||||
|
||||
/^abc$/
|
||||
abc
|
||||
*** Failers
|
||||
qqq\nabc
|
||||
abc\nzzz
|
||||
qqq\nabc\nzzz
|
||||
|
||||
/\`(.)*\'/xs
|
||||
abc\ndef
|
||||
|
||||
/[-az]+/x
|
||||
az-
|
||||
*** Failers
|
||||
b
|
||||
|
||||
/[az-]+/x
|
||||
za-
|
||||
*** Failers
|
||||
b
|
||||
|
||||
/[az-]+/x
|
||||
a-z
|
||||
*** Failers
|
||||
b
|
||||
|
||||
/[a-z]+/x
|
||||
abcdxyz
|
||||
|
||||
/[0-9-]+/x
|
||||
12-34
|
||||
*** Failers
|
||||
aaa
|
||||
|
||||
/[0-9-z]+/x
|
||||
12-34z
|
||||
*** Failers
|
||||
aaa
|
||||
|
||||
/\x5c/
|
||||
\\
|
||||
|
||||
/\x20Z/
|
||||
the Zoo
|
||||
*** Failers
|
||||
Zulu
|
||||
|
||||
/(abc)\1/xi
|
||||
abcabc
|
||||
ABCabc
|
||||
abcABC
|
||||
|
||||
/ab{3cd/
|
||||
ab{3cd
|
||||
|
||||
/ab{3,cd/
|
||||
ab{3,cd
|
||||
|
||||
/ab{3,4a}cd/
|
||||
ab{3,4a}cd
|
||||
|
||||
/{4,5a}bc/x
|
||||
{4,5a}bc
|
||||
|
||||
/^a.b/
|
||||
a\rb
|
||||
*** Failers
|
||||
a\nb
|
||||
|
||||
/abc$/
|
||||
abc
|
||||
*** Failers
|
||||
abc\n
|
||||
abc\ndef
|
||||
|
||||
/(abc)\o123/x
|
||||
abc\x53
|
||||
|
||||
/(abc)\o223/x
|
||||
abc\x93
|
||||
|
||||
/(abc)\o323/x
|
||||
abc\xd3
|
||||
|
||||
/(abc)\500/x
|
||||
abc\x40
|
||||
abc\100
|
||||
|
||||
/(abc)\5000/x
|
||||
abc\x400
|
||||
abc\x40\x30
|
||||
abc\1000
|
||||
abc\100\x30
|
||||
abc\100\060
|
||||
abc\100\60
|
||||
|
||||
/abc\81/
|
||||
abc\081
|
||||
abc\0\x38\x31
|
||||
|
||||
/abc\91/
|
||||
abc\091
|
||||
abc\0\x39\x31
|
||||
|
||||
/(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)\12/x
|
||||
abcdefghijkla2
|
||||
|
||||
/(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\123/x
|
||||
abcdefghijka23
|
||||
|
||||
/ab\gdef/x
|
||||
abgdef
|
||||
|
||||
/a{0}bc/x
|
||||
bc
|
||||
|
||||
/(a|(bc)){0,0}xyz/x
|
||||
xyz
|
||||
|
||||
/abc[\o10]de/x
|
||||
abc\010de
|
||||
|
||||
/abc[\o1]de/x
|
||||
abc\1de
|
||||
|
||||
/(abc)[\o1]de/x
|
||||
abc\1de
|
||||
|
||||
/^([^a])([^\b])([^c]*)([^d]{3,4})/x
|
||||
baNOTccccd
|
||||
baNOTcccd
|
||||
baNOTccd
|
||||
bacccd
|
||||
*** Failers
|
||||
anything
|
||||
b\bc
|
||||
baccd
|
||||
|
||||
/[^a]/
|
||||
Abc
|
||||
|
||||
/[^a]/i
|
||||
Abc
|
||||
|
||||
/[^a]+/x
|
||||
AAAaAbc
|
||||
|
||||
/[^a]+/xi
|
||||
AAAaAbc
|
||||
|
||||
/[^a]+/x
|
||||
bbb\nccc
|
||||
|
||||
/[^k]$/x
|
||||
abc
|
||||
*** Failers
|
||||
abk
|
||||
|
||||
/[^k]{2,3}$/x
|
||||
abc
|
||||
kbc
|
||||
kabc
|
||||
*** Failers
|
||||
abk
|
||||
akb
|
||||
akk
|
||||
|
||||
/^[0-9]{8,}\@.+[^k]$/x
|
||||
12345678\@a.b.c.d
|
||||
123456789\@x.y.z
|
||||
*** Failers
|
||||
12345678\@x.y.uk
|
||||
1234567\@a.b.c.d
|
||||
|
||||
/(a)\1{8,}/x
|
||||
aaaaaaaaa
|
||||
aaaaaaaaaa
|
||||
*** Failers
|
||||
aaaaaaa
|
||||
|
||||
/[^a]/x
|
||||
aaaabcd
|
||||
aaAabcd
|
||||
|
||||
/[^a]/i
|
||||
aaaabcd
|
||||
aaAabcd
|
||||
|
||||
/[^az]/x
|
||||
aaaabcd
|
||||
aaAabcd
|
||||
|
||||
/[^az]/i
|
||||
aaaabcd
|
||||
aaAabcd
|
||||
|
||||
/\o000\o001\o002\o003\o004\o005\o006\o007\o010\o011\o012\o013\o014\o015\o016\o017\o020\o021\o022\o023\o024\o025\o026\o027\o030\o031\o032\o033\o034\o035\o036\o037\o040\o041\o042\o043\o044\o045\o046\o047\o050\o051\o052\o053\o054\o055\o056\o057\o060\o061\o062\o063\o064\o065\o066\o067\o070\o071\o072\o073\o074\o075\o076\o077\o100\o101\o102\o103\o104\o105\o106\o107\o110\o111\o112\o113\o114\o115\o116\o117\o120\o121\o122\o123\o124\o125\o126\o127\o130\o131\o132\o133\o134\o135\o136\o137\o140\o141\o142\o143\o144\o145\o146\o147\o150\o151\o152\o153\o154\o155\o156\o157\o160\o161\o162\o163\o164\o165\o166\o167\o170\o171\o172\o173\o174\o175\o176\o177\o200\o201\o202\o203\o204\o205\o206\o207\o210\o211\o212\o213\o214\o215\o216\o217\o220\o221\o222\o223\o224\o225\o226\o227\o230\o231\o232\o233\o234\o235\o236\o237\o240\o241\o242\o243\o244\o245\o246\o247\o250\o251\o252\o253\o254\o255\o256\o257\o260\o261\o262\o263\o264\o265\o266\o267\o270\o271\o272\o273\o274\o275\o276\o277\o300\o301\o302\o303\o304\o305\o306\o307\o310\o311\o312\o313\o314\o315\o316\o317\o320\o321\o322\o323\o324\o325\o326\o327\o330\o331\o332\o333\o334\o335\o336\o337\o340\o341\o342\o343\o344\o345\o346\o347\o350\o351\o352\o353\o354\o355\o356\o357\o360\o361\o362\o363\o364\o365\o366\o367\o370\o371\o372\o373\o374\o375\o376\o377/
|
||||
\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377
|
||||
|
||||
/P[^*]TAIRE[^*]{1,6}LL/x
|
||||
xxxxxxxxxxxPSTAIREISLLxxxxxxxxx
|
||||
|
||||
/P[^*]TAIRE[^*]{1,}LL/x
|
||||
xxxxxxxxxxxPSTAIREISLLxxxxxxxxx
|
||||
|
||||
/(\.[0-9][0-9][1-9]?)[0-9]+/x
|
||||
1.230003938
|
||||
1.875000282
|
||||
1.235
|
||||
|
||||
/\b(foo)[ \t]+(\w+)/xi
|
||||
Food is on the foo table
|
||||
|
||||
/foo(.*)bar/x
|
||||
The food is under the bar in the barn.
|
||||
|
||||
/foo(.*)bar/x
|
||||
The food is under the bar in the barn.
|
||||
|
||||
/(.*)([0-9]*)/x
|
||||
I have 2 numbers: 53147
|
||||
|
||||
/(.*)([0-9]+)/x
|
||||
I have 2 numbers: 53147
|
||||
|
||||
/(.*)([0-9]*)/x
|
||||
I have 2 numbers: 53147
|
||||
|
||||
/(.*)([0-9]+)/x
|
||||
I have 2 numbers: 53147
|
||||
|
||||
/(.*)([0-9]+)$/x
|
||||
I have 2 numbers: 53147
|
||||
|
||||
/(.*)([0-9]+)$/x
|
||||
I have 2 numbers: 53147
|
||||
|
||||
/(.*)\b([0-9]+)$/x
|
||||
I have 2 numbers: 53147
|
||||
|
||||
/(.*[^0-9])([0-9]+)$/x
|
||||
I have 2 numbers: 53147
|
||||
|
||||
/^[W-]46]/x
|
||||
W46]789
|
||||
-46]789
|
||||
*** Failers
|
||||
Wall
|
||||
Zebra
|
||||
42
|
||||
[abcd]
|
||||
]abcd[
|
||||
|
||||
/^[W-\46]/x
|
||||
W46]789
|
||||
Wall
|
||||
Zebra
|
||||
Xylophone
|
||||
42
|
||||
[abcd]
|
||||
\\backslash
|
||||
*** Failers
|
||||
-46]789
|
||||
well
|
||||
|
||||
/[0-9][0-9]\/[0-9][0-9]\/[0-9][0-9][0-9][0-9]/x
|
||||
01/01/2000
|
||||
|
||||
/^(a){0,0}/x
|
||||
bcd
|
||||
abc
|
||||
aab
|
||||
|
||||
/^(a){0,1}/x
|
||||
bcd
|
||||
abc
|
||||
aab
|
||||
|
||||
/^(a){0,2}/x
|
||||
bcd
|
||||
abc
|
||||
aab
|
||||
|
||||
/^(a){0,3}/x
|
||||
bcd
|
||||
abc
|
||||
aab
|
||||
aaa
|
||||
|
||||
/^(a){0,}/x
|
||||
bcd
|
||||
abc
|
||||
aab
|
||||
aaa
|
||||
aaaaaaaa
|
||||
|
||||
/^(a){1,1}/x
|
||||
abc
|
||||
aab
|
||||
*** Failers:
|
||||
bcd
|
||||
|
||||
/^(a){1,2}/x
|
||||
abc
|
||||
aab
|
||||
*** Failers:
|
||||
bcd
|
||||
|
||||
/^(a){1,3}/x
|
||||
abc
|
||||
aab
|
||||
aaa
|
||||
*** Failers:
|
||||
bcd
|
||||
|
||||
/^(a){1,}/x
|
||||
abc
|
||||
aab
|
||||
aaa
|
||||
aaaaaaaa
|
||||
*** Failers:
|
||||
bcd
|
||||
|
||||
/.*\.gif/x
|
||||
borfle\nbib.gif\nno
|
||||
|
||||
/.{0,}\.gif/x
|
||||
borfle\nbib.gif\nno
|
||||
|
||||
/^.*\.gif/xs
|
||||
borfle\nbib.gif\nno
|
||||
|
||||
/.*$/
|
||||
borfle\nbib.gif\nno
|
||||
|
||||
/.*$/
|
||||
*** Failers
|
||||
borfle\nbib.gif\nno\n
|
||||
|
||||
/(.*X|^B)/x
|
||||
abcde\n1234Xyz
|
||||
BarFoo
|
||||
*** Failers
|
||||
abcde\nBar
|
||||
|
||||
/^.*B/x
|
||||
**** Failers
|
||||
abc\nB
|
||||
|
||||
/^[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]/x
|
||||
123456654321
|
||||
|
||||
/^[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]/
|
||||
123456654321
|
||||
|
||||
/^[abc]{12}/x
|
||||
abcabcabcabc
|
||||
|
||||
/^[a-c]{12}/x
|
||||
abcabcabcabc
|
||||
|
||||
/^(a|b|c){12}/x
|
||||
abcabcabcabc
|
||||
|
||||
/^[abcdefghijklmnopqrstuvwxy0123456789]/x
|
||||
n
|
||||
*** Failers
|
||||
z
|
||||
|
||||
/abcde{0,0}/x
|
||||
abcd
|
||||
*** Failers
|
||||
abce
|
||||
|
||||
/ab[cd]{0,0}e/x
|
||||
abe
|
||||
*** Failers
|
||||
abcde
|
||||
|
||||
/ab(c){0,0}d/x
|
||||
abd
|
||||
*** Failers
|
||||
abcd
|
||||
|
||||
/a(b*)/x
|
||||
a
|
||||
ab
|
||||
abbbb
|
||||
*** Failers
|
||||
bbbbb
|
||||
|
||||
/ab[0-9]{0}e/x
|
||||
abe
|
||||
*** Failers
|
||||
ab1e
|
||||
|
||||
/"([^\\"]+|\\.)*"/x
|
||||
the \"quick\" brown fox
|
||||
\"the \\\"quick\\\" brown fox\"
|
||||
|
||||
/.*/g+
|
||||
abc
|
||||
|
||||
/\b/g+
|
||||
abc
|
||||
|
||||
/\b/+g
|
||||
abc
|
||||
|
||||
//g
|
||||
abc
|
||||
|
||||
/a[^a]b/x
|
||||
acb
|
||||
a\nb
|
||||
|
||||
/a.b/
|
||||
acb
|
||||
*** Failers
|
||||
a\nb
|
||||
|
||||
/^(b+|a){1,2}c/x
|
||||
bac
|
||||
bbac
|
||||
bbbac
|
||||
bbbbac
|
||||
bbbbbac
|
||||
|
||||
/^(b+|a){1,2}c/x
|
||||
bac
|
||||
bbac
|
||||
bbbac
|
||||
bbbbac
|
||||
bbbbbac
|
||||
|
||||
/\x0{ab}/
|
||||
\0{ab}
|
||||
|
||||
/(A|B)*CD/x
|
||||
CD
|
||||
|
||||
/(A|B)*CD/x
|
||||
CD
|
||||
|
||||
/(AB)*\1/x
|
||||
ABABAB
|
||||
|
||||
/(AB)*\1/x
|
||||
ABABAB
|
||||
|
||||
/ End of testinput1 /
|
||||
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
+1734
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -1,326 +0,0 @@
|
||||
{ 0, 0, "2.8.2 Regular Expression General Requirement", NULL, },
|
||||
{ 2, 4, "bb*", "abbbc", },
|
||||
{ 2, 2, "bb*", "ababbbc", },
|
||||
{ 7, 9, "A#*::", "A:A#:qA::qA#::qA##::q", },
|
||||
{ 1, 5, "A#*::", "A##::A#::qA::qA#:q", },
|
||||
{ 0, 0, "2.8.3.1.2 BRE Special Characters", NULL, },
|
||||
{ 0, 0, "GA108", NULL, },
|
||||
{ 2, 2, "\\.", "a.c", },
|
||||
{ 2, 2, "\\[", "a[c", },
|
||||
{ 2, 2, "\\\\", "a\\c", },
|
||||
{ 2, 2, "\\*", "a*c", },
|
||||
{ 2, 2, "\\^", "a^c", },
|
||||
{ 2, 2, "\\$", "a$c", },
|
||||
{ 7, 11, "X\\*Y\\*8", "Y*8X*8X*Y*8", },
|
||||
{ 0, 0, "GA109", NULL, },
|
||||
{ 2, 2, "[.]", "a.c", },
|
||||
{ 2, 2, "[[]", "a[c", },
|
||||
{ -1, -1, "[[]", "ac", },
|
||||
{ 2, 2, "[\\]", "a\\c", },
|
||||
{ 1, 1, "[\\a]", "abc", },
|
||||
{ 2, 2, "[\\.]", "a\\.c", },
|
||||
{ 2, 2, "[\\.]", "a.\\c", },
|
||||
{ 2, 2, "[*]", "a*c", },
|
||||
{ 2, 2, "[$]", "a$c", },
|
||||
{ 2, 2, "[X*Y8]", "7*8YX", },
|
||||
{ 0, 0, "GA110", NULL, },
|
||||
{ 2, 2, "*", "a*c", },
|
||||
{ 3, 4, "*a", "*b*a*c", },
|
||||
{ 1, 5, "**9=", "***9=9", },
|
||||
{ 0, 0, "GA111", NULL, },
|
||||
{ 1, 1, "^*", "*bc", },
|
||||
{ -1, -1, "^*", "a*c", },
|
||||
{ -1, -1, "^*", "^*ab", },
|
||||
{ 1, 5, "^**9=", "***9=", },
|
||||
{ -1, -1, "^*5<*9", "5<9*5<*9", },
|
||||
{ 0, 0, "GA112", NULL, },
|
||||
{ 2, 3, "\\(*b\\)", "a*b", },
|
||||
{ -1, -1, "\\(*b\\)", "ac", },
|
||||
{ 1, 6, "A\\(**9\\)=", "A***9=79", },
|
||||
{ 0, 0, "GA113(1)", NULL, },
|
||||
{ 1, 3, "\\(^*ab\\)", "*ab", },
|
||||
{ -1, -1, "\\(^*ab\\)", "^*ab", },
|
||||
{ -1, -1, "\\(^*b\\)", "a*b", },
|
||||
{ -1, -1, "\\(^*b\\)", "^*b", },
|
||||
{ 0, 0, "GA114", NULL, },
|
||||
{ 1, 3, "a^b", "a^b", },
|
||||
{ 1, 3, "a\\^b", "a^b", },
|
||||
{ 1, 1, "^^", "^bc", },
|
||||
{ 2, 2, "\\^", "a^c", },
|
||||
{ 1, 1, "[c^b]", "^abc", },
|
||||
{ 1, 1, "[\\^ab]", "^ab", },
|
||||
{ 2, 2, "[\\^ab]", "c\\d", },
|
||||
{ -1, -1, "[^^]", "^", },
|
||||
{ 1, 3, "\\(a^b\\)", "a^b", },
|
||||
{ 1, 3, "\\(a\\^b\\)", "a^b", },
|
||||
{ 2, 2, "\\(\\^\\)", "a^b", },
|
||||
{ 0, 0, "GA115", NULL, },
|
||||
{ 3, 3, "$$", "ab$", },
|
||||
{ -1, -1, "$$", "$ab", },
|
||||
{ 2, 3, "$c", "a$c", },
|
||||
{ 2, 2, "[$]", "a$c", },
|
||||
{ 1, 2, "\\$a", "$a", },
|
||||
{ 3, 3, "\\$$", "ab$", },
|
||||
{ 2, 6, "A\\([34]$[34]\\)B", "XA4$3BY", },
|
||||
{ 0, 0, "2.8.3.1.3 Periods in BREs", NULL, },
|
||||
{ 0, 0, "GA116", NULL, },
|
||||
{ 1, 1, ".", "abc", },
|
||||
{ -1, -1, ".ab", "abc", },
|
||||
{ 1, 3, "ab.", "abc", },
|
||||
{ 1, 3, "a.b", "a,b", },
|
||||
{ -1, -1, ".......", "PqRs6", },
|
||||
{ 1, 7, ".......", "PqRs6T8", },
|
||||
{ 0, 0, "2.8.3.2 RE Bracket Expression", NULL, },
|
||||
{ 0, 0, "GA118", NULL, },
|
||||
{ 2, 2, "[abc]", "xbyz", },
|
||||
{ -1, -1, "[abc]", "xyz", },
|
||||
{ 2, 2, "[abc]", "xbay", },
|
||||
{ 0, 0, "GA119", NULL, },
|
||||
{ 2, 2, "[^a]", "abc", },
|
||||
{ 4, 4, "[^]cd]", "cd]ef", },
|
||||
{ 2, 2, "[^abc]", "axyz", },
|
||||
{ -1, -1, "[^abc]", "abc", },
|
||||
{ 3, 3, "[^[.a.]b]", "abc", },
|
||||
{ 3, 3, "[^[=a=]b]", "abc", },
|
||||
{ 2, 2, "[^-ac]", "abcde-", },
|
||||
{ 2, 2, "[^ac-]", "abcde-", },
|
||||
{ 3, 3, "[^a-b]", "abcde", },
|
||||
{ 3, 3, "[^a-bd-e]", "dec", },
|
||||
{ 2, 2, "[^---]", "-ab", },
|
||||
{ 16, 16, "[^a-zA-Z0-9]", "pqrstVWXYZ23579#", },
|
||||
{ 0, 0, "GA120(1)", NULL, },
|
||||
{ 3, 3, "[]a]", "cd]ef", },
|
||||
{ 1, 1, "[]-a]", "a_b", },
|
||||
{ 3, 3, "[][.-.]-0]", "ab0-]", },
|
||||
{ 1, 1, "[]^a-z]", "string", },
|
||||
{ 0, 0, "GA120(2)", NULL, },
|
||||
{ 4, 4, "[^]cd]", "cd]ef", },
|
||||
{ 0, 0, "[^]]*", "]]]]]]]]X", },
|
||||
{ 0, 0, "[^]]*", "]]]]]]]]", },
|
||||
{ 9, 9, "[^]]\\{1,\\}", "]]]]]]]]X", },
|
||||
{ -1, -1, "[^]]\\{1,\\}", "]]]]]]]]", },
|
||||
{ 0, 0, "GA120(3)", NULL, },
|
||||
{ 3, 3, "[c[.].]d]", "ab]cd", },
|
||||
{ 2, 8, "[a-z]*[[.].]][A-Z]*", "Abcd]DEFg", },
|
||||
{ 0, 0, "GA121", NULL, },
|
||||
{ 2, 2, "[[.a.]b]", "Abc", },
|
||||
{ 1, 1, "[[.a.]b]", "aBc", },
|
||||
{ -1, -1, "[[.a.]b]", "ABc", },
|
||||
{ 3, 3, "[^[.a.]b]", "abc", },
|
||||
{ 3, 3, "[][.-.]-0]", "ab0-]", },
|
||||
{ 3, 3, "[A-[.].]c]", "ab]!", },
|
||||
{ 0, 0, "GA122", NULL, },
|
||||
{ -2, -2, "[[.ch.]]", "abc", },
|
||||
{ -2, -2, "[[.ab.][.CD.][.EF.]]", "yZabCDEFQ9", },
|
||||
{ 0, 0, "GA125", NULL, },
|
||||
{ 2, 2, "[[=a=]b]", "Abc", },
|
||||
{ 1, 1, "[[=a=]b]", "aBc", },
|
||||
{ -1, -1, "[[=a=]b]", "ABc", },
|
||||
{ 3, 3, "[^[=a=]b]", "abc", },
|
||||
{ 0, 0, "GA126", NULL, },
|
||||
{ 0, 0, NULL, "the expected result for [[:alnum:]]* is 2-7 which is wrong" },
|
||||
{ 0, 0, "[[:alnum:]]*", " aB28gH", },
|
||||
{ 2, 7, "[[:alnum:]][[:alnum:]]*", " aB28gH", },
|
||||
{ 0, 0, NULL, "the expected result for [^[:alnum:]]* is 2-5 which is wrong" },
|
||||
{ 0, 0, "[^[:alnum:]]*", "2 ,a", },
|
||||
{ 2, 5, "[^[:alnum:]][^[:alnum:]]*", "2 ,a", },
|
||||
{ 0, 0, NULL, "the expected result for [[:alpha:]]* is 2-5 which is wrong" },
|
||||
{ 0, 0, "[[:alpha:]]*", " aBgH2", },
|
||||
{ 2, 5, "[[:alpha:]][[:alpha:]]*", " aBgH2", },
|
||||
{ 1, 6, "[^[:alpha:]]*", "2 8,a", },
|
||||
{ 1, 2, "[[:blank:]]*", " \r", },
|
||||
{ 1, 8, "[^[:blank:]]*", "aB28gH, ", },
|
||||
{ 1, 2, "[[:cntrl:]]*", " ", },
|
||||
{ 1, 8, "[^[:cntrl:]]*", "aB2 8gh,", },
|
||||
{ 0, 0, NULL, "the expected result for [[:digit:]]* is 2-3 which is wrong" },
|
||||
{ 0, 0, "[[:digit:]]*", "a28", },
|
||||
{ 2, 3, "[[:digit:]][[:digit:]]*", "a28", },
|
||||
{ 1, 8, "[^[:digit:]]*", "aB gH,", },
|
||||
{ 1, 7, "[[:graph:]]*", "aB28gH, ", },
|
||||
{ 1, 3, "[^[:graph:]]*", " ,", },
|
||||
{ 1, 2, "[[:lower:]]*", "agB", },
|
||||
{ 1, 8, "[^[:lower:]]*", "B2 8H,a", },
|
||||
{ 1, 8, "[[:print:]]*", "aB2 8gH, ", },
|
||||
{ 1, 2, "[^[:print:]]*", " ", },
|
||||
{ 0, 0, NULL, "the expected result for [[:punct:]]* is 2-2 which is wrong" },
|
||||
{ 0, 0, "[[:punct:]]*", "a,2", },
|
||||
{ 2, 3, "[[:punct:]][[:punct:]]*", "a,,2", },
|
||||
{ 1, 9, "[^[:punct:]]*", "aB2 8gH", },
|
||||
{ 1, 3, "[[:space:]]*", " \r", },
|
||||
{ 0, 0, NULL, "the expected result for [^[:space:]]* is 2-9 which is wrong" },
|
||||
{ 0, 0, "[^[:space:]]*", " aB28gH, ", },
|
||||
{ 2, 9, "[^[:space:]][^[:space:]]*", " aB28gH, ", },
|
||||
{ 0, 0, NULL, "the expected result for [[:upper:]]* is 2-3 which is wrong" },
|
||||
{ 0, 0, "[[:upper:]]*", "aBH2", },
|
||||
{ 2, 3, "[[:upper:]][[:upper:]]*", "aBH2", },
|
||||
{ 1, 8, "[^[:upper:]]*", "a2 8g,B", },
|
||||
{ 0, 0, NULL, "the expected result for [[:xdigit:]]* is 2-5 which is wrong" },
|
||||
{ 0, 0, "[[:xdigit:]]*", "gaB28h", },
|
||||
{ 2, 5, "[[:xdigit:]][[:xdigit:]]*", "gaB28h", },
|
||||
{ 0, 0, NULL, "the expected result for [^[:xdigit:]]* is 2-7 which is wrong" },
|
||||
{ 2, 7, "[^[:xdigit:]][^[:xdigit:]]*", "a gH,2", },
|
||||
{ 0, 0, "GA127", NULL, },
|
||||
{ -2, -2, "[b-a]", "abc", },
|
||||
{ 1, 1, "[a-c]", "bbccde", },
|
||||
{ 2, 2, "[a-b]", "-bc", },
|
||||
{ 3, 3, "[a-z0-9]", "AB0", },
|
||||
{ 3, 3, "[^a-b]", "abcde", },
|
||||
{ 3, 3, "[^a-bd-e]", "dec", },
|
||||
{ 1, 1, "[]-a]", "a_b", },
|
||||
{ 2, 2, "[+--]", "a,b", },
|
||||
{ 2, 2, "[--/]", "a.b", },
|
||||
{ 2, 2, "[^---]", "-ab", },
|
||||
{ 3, 3, "[][.-.]-0]", "ab0-]", },
|
||||
{ 3, 3, "[A-[.].]c]", "ab]!", },
|
||||
{ 2, 6, "bc[d-w]xy", "abchxyz", },
|
||||
{ 0, 0, "GA129", NULL, },
|
||||
{ 1, 1, "[a-cd-f]", "dbccde", },
|
||||
{ -1, -1, "[a-ce-f]", "dBCCdE", },
|
||||
{ 2, 4, "b[n-zA-M]Y", "absY9Z", },
|
||||
{ 2, 4, "b[n-zA-M]Y", "abGY9Z", },
|
||||
{ 0, 0, "GA130", NULL, },
|
||||
{ 3, 3, "[-xy]", "ac-", },
|
||||
{ 2, 4, "c[-xy]D", "ac-D+", },
|
||||
{ 2, 2, "[--/]", "a.b", },
|
||||
{ 2, 4, "c[--/]D", "ac.D+b", },
|
||||
{ 2, 2, "[^-ac]", "abcde-", },
|
||||
{ 1, 3, "a[^-ac]c", "abcde-", },
|
||||
{ 3, 3, "[xy-]", "zc-", },
|
||||
{ 2, 4, "c[xy-]7", "zc-786", },
|
||||
{ 2, 2, "[^ac-]", "abcde-", },
|
||||
{ 2, 4, "a[^ac-]c", "5abcde-", },
|
||||
{ 2, 2, "[+--]", "a,b", },
|
||||
{ 2, 4, "a[+--]B", "Xa,By", },
|
||||
{ 2, 2, "[^---]", "-ab", },
|
||||
{ 4, 6, "X[^---]Y", "X-YXaYXbY", },
|
||||
{ 0, 0, "2.8.3.3 BREs Matching Multiple Characters", NULL, },
|
||||
{ 0, 0, "GA131", NULL, },
|
||||
{ 3, 4, "cd", "abcdeabcde", },
|
||||
{ 1, 2, "ag*b", "abcde", },
|
||||
{ -1, -1, "[a-c][e-f]", "abcdef", },
|
||||
{ 3, 4, "[a-c][e-f]", "acbedf", },
|
||||
{ 4, 8, "abc*XYZ", "890abXYZ#*", },
|
||||
{ 4, 9, "abc*XYZ", "890abcXYZ#*", },
|
||||
{ 4, 15, "abc*XYZ", "890abcccccccXYZ#*", },
|
||||
{ -1, -1, "abc*XYZ", "890abc*XYZ#*", },
|
||||
{ 0, 0, "GA132", NULL, },
|
||||
{ 2, 4, "\\(*bc\\)", "a*bc", },
|
||||
{ 1, 2, "\\(ab\\)", "abcde", },
|
||||
{ 1, 10, "\\(a\\(b\\(c\\(d\\(e\\(f\\(g\\)h\\(i\\(j\\)\\)\\)\\)\\)\\)\\)\\)", "abcdefghijk", },
|
||||
{ 3, 8, "43\\(2\\(6\\)*0\\)AB", "654320ABCD", },
|
||||
{ 3, 9, "43\\(2\\(7\\)*0\\)AB", "6543270ABCD", },
|
||||
{ 3, 12, "43\\(2\\(7\\)*0\\)AB", "6543277770ABCD", },
|
||||
{ 0, 0, "GA133", NULL, },
|
||||
{ 1, 10, "\\(a\\(b\\(c\\(d\\(e\\(f\\(g\\)h\\(i\\(j\\)\\)\\)\\)\\)\\)\\)\\)", "abcdefghijk", },
|
||||
{ -1, -1, "\\(a\\(b\\(c\\(d\\(e\\(f\\(g\\)h\\(i\\(k\\)\\)\\)\\)\\)\\)\\)\\)", "abcdefghijk", },
|
||||
{ 0, 0, "GA134", NULL, },
|
||||
{ 2, 4, "\\(bb*\\)", "abbbc", },
|
||||
{ 2, 2, "\\(bb*\\)", "ababbbc", },
|
||||
{ 1, 6, "a\\(.*b\\)", "ababbbc", },
|
||||
{ 1, 2, "a\\(b*\\)", "ababbbc", },
|
||||
{ 1, 20, "a\\(.*b\\)c", "axcaxbbbcsxbbbbbbbbc", },
|
||||
{ 0, 0, "GA135", NULL, },
|
||||
{ 1, 7, "\\(a\\(b\\(c\\(d\\(e\\)\\)\\)\\)\\)\\4", "abcdededede", },
|
||||
{ 0, 0, NULL, "POSIX does not really specify whether a\\(b\\)*c\\1 matches acb." },
|
||||
{ 0, 0, NULL, "back references are supposed to expand to the last match, but what" },
|
||||
{ 0, 0, NULL, "if there never was a match as in this case?" },
|
||||
{ -1, -1, "a\\(b\\)*c\\1", "acb", },
|
||||
{ 1, 11, "\\(a\\(b\\(c\\(d\\(e\\(f\\(g\\)h\\(i\\(j\\)\\)\\)\\)\\)\\)\\)\\)\\9", "abcdefghijjk", },
|
||||
{ 0, 0, "GA136", NULL, },
|
||||
{ 0, 0, NULL, "These two tests have the same problem as the test in GA135. No match" },
|
||||
{ 0, 0, NULL, "of a subexpression, why should the back reference be usable?" },
|
||||
{ 0, 0, NULL, "1 2 a\\(b\\)*c\\1 acb" },
|
||||
{ 0, 0, NULL, "4 7 a\\(b\\(c\\(d\\(f\\)*\\)\\)\\)\\4¦xYzabcdePQRST" },
|
||||
{ -1, -1, "a\\(b\\)*c\\1", "acb", },
|
||||
{ -1, -1, "a\\(b\\(c\\(d\\(f\\)*\\)\\)\\)\\4", "xYzabcdePQRST", },
|
||||
{ 0, 0, "GA137", NULL, },
|
||||
{ -2, -2, "\\(a\\(b\\)\\)\\3", "foo", },
|
||||
{ -2, -2, "\\(a\\(b\\)\\)\\(a\\(b\\)\\)\\5", "foo", },
|
||||
{ 0, 0, "GA138", NULL, },
|
||||
{ 1, 2, "ag*b", "abcde", },
|
||||
{ 1, 10, "a.*b", "abababvbabc", },
|
||||
{ 2, 5, "b*c", "abbbcdeabbbbbbcde", },
|
||||
{ 2, 5, "bbb*c", "abbbcdeabbbbbbcde", },
|
||||
{ 1, 5, "a\\(b\\)*c\\1", "abbcbbb", },
|
||||
{ -1, -1, "a\\(b\\)*c\\1", "abbdbd", },
|
||||
{ 0, 0, "\\([a-c]*\\)\\1", "abcacdef", },
|
||||
{ 1, 6, "\\([a-c]*\\)\\1", "abcabcabcd", },
|
||||
{ 1, 2, "a^*b", "ab", },
|
||||
{ 1, 5, "a^*b", "a^^^b", },
|
||||
{ 0, 0, "GA139", NULL, },
|
||||
{ 1, 2, "a\\{2\\}", "aaaa", },
|
||||
{ 1, 7, "\\([a-c]*\\)\\{0,\\}", "aabcaab", },
|
||||
{ 1, 2, "\\(a\\)\\1\\{1,2\\}", "aabc", },
|
||||
{ 1, 3, "\\(a\\)\\1\\{1,2\\}", "aaaabc", },
|
||||
{ 0, 0, NULL, "the expression \\(\\(a\\)\\1\\)\\{1,2\\} is ill-formed, using \\2" },
|
||||
{ 1, 4, "\\(\\(a\\)\\2\\)\\{1,2\\}", "aaaabc", },
|
||||
{ 0, 0, "GA140", NULL, },
|
||||
{ 1, 2, "a\\{2\\}", "aaaa", },
|
||||
{ -1, -1, "a\\{2\\}", "abcd", },
|
||||
{ 0, 0, "a\\{0\\}", "aaaa", },
|
||||
{ 1, 64, "a\\{64\\}", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", },
|
||||
{ 0, 0, "GA141", NULL, },
|
||||
{ 1, 7, "\\([a-c]*\\)\\{0,\\}", "aabcaab", },
|
||||
{ 0, 0, NULL, "the expected result for \\([a-c]*\\)\\{2,\\} is failure which isn't correct" },
|
||||
{ 1, 3, "\\([a-c]*\\)\\{2,\\}", "abcdefg", },
|
||||
{ 1, 3, "\\([a-c]*\\)\\{1,\\}", "abcdefg", },
|
||||
{ -1, -1, "a\\{64,\\}", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", },
|
||||
{ 0, 0, "GA142", NULL, },
|
||||
{ 1, 3, "a\\{2,3\\}", "aaaa", },
|
||||
{ -1, -1, "a\\{2,3\\}", "abcd", },
|
||||
{ 0, 0, "\\([a-c]*\\)\\{0,0\\}", "foo", },
|
||||
{ 1, 63, "a\\{1,63\\}", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", },
|
||||
{ 0, 0, "2.8.3.4 BRE Precedence", NULL, },
|
||||
{ 0, 0, "GA143", NULL, },
|
||||
{ 0, 0, NULL, "There are numerous bugs in the original version." },
|
||||
{ 2, 19, "\\^\\[[[.].]]\\\\(\\\\1\\\\)\\*\\\\{1,2\\\\}\\$", "a^[]\\(\\1\\)*\\{1,2\\}$b", },
|
||||
{ 1, 6, "[[=*=]][[=\\=]][[=]=]][[===]][[...]][[:punct:]]", "*\\]=.;", },
|
||||
{ 1, 6, "[$\\(*\\)^]*", "$\\()*^", },
|
||||
{ 1, 1, "[\\1]", "1", },
|
||||
{ 1, 1, "[\\{1,2\\}]", "{", },
|
||||
{ 0, 0, NULL, "the expected result for \\(*\\)*\\1* is 2-2 which isn't correct" },
|
||||
{ 0, 0, "\\(*\\)*\\1*", "a*b*11", },
|
||||
{ 2, 3, "\\(*\\)*\\1*b", "a*b*11", },
|
||||
{ 0, 0, NULL, "the expected result for \\(a\\(b\\{1,2\\}\\)\\{1,2\\}\\) is 1-5 which isn't correct" },
|
||||
{ 1, 3, "\\(a\\(b\\{1,2\\}\\)\\{1,2\\}\\)", "abbab", },
|
||||
{ 1, 5, "\\(a\\(b\\{1,2\\}\\)\\)\\{1,2\\}", "abbab", },
|
||||
{ 1, 1, "^\\(^\\(^a$\\)$\\)$", "a", },
|
||||
{ 1, 2, "\\(a\\)\\1$", "aa", },
|
||||
{ 1, 3, "ab*", "abb", },
|
||||
{ 1, 4, "ab\\{2,4\\}", "abbbc", },
|
||||
{ 0, 0, "2.8.3.5 BRE Expression Anchoring", NULL, },
|
||||
{ 0, 0, "GA144", NULL, },
|
||||
{ 1, 1, "^a", "abc", },
|
||||
{ -1, -1, "^b", "abc", },
|
||||
{ -1, -1, "^[a-zA-Z]", "99Nine", },
|
||||
{ 1, 4, "^[a-zA-Z]*", "Nine99", },
|
||||
{ 0, 0, "GA145(1)", NULL, },
|
||||
{ 1, 2, "\\(^a\\)\\1", "aabc", },
|
||||
{ -1, -1, "\\(^a\\)\\1", "^a^abc", },
|
||||
{ 1, 2, "\\(^^a\\)", "^a", },
|
||||
{ 1, 1, "\\(^^\\)", "^^", },
|
||||
{ 1, 3, "\\(^abc\\)", "abcdef", },
|
||||
{ -1, -1, "\\(^def\\)", "abcdef", },
|
||||
{ 0, 0, "GA146", NULL, },
|
||||
{ 3, 3, "a$", "cba", },
|
||||
{ -1, -1, "a$", "abc", },
|
||||
{ 5, 7, "[a-z]*$", "99ZZxyz", },
|
||||
{ 0, 0, NULL, "the expected result for [a-z]*$ is failure which isn't correct" },
|
||||
{ 10, 9, "[a-z]*$", "99ZZxyz99", },
|
||||
{ 3, 3, "$$", "ab$", },
|
||||
{ -1, -1, "$$", "$ab", },
|
||||
{ 3, 3, "\\$$", "ab$", },
|
||||
{ 0, 0, "GA147(1)", NULL, },
|
||||
{ -1, -1, "\\(a$\\)\\1", "bcaa", },
|
||||
{ -1, -1, "\\(a$\\)\\1", "ba$", },
|
||||
{ -1, -1, "\\(ab$\\)", "ab$", },
|
||||
{ 1, 2, "\\(ab$\\)", "ab", },
|
||||
{ 4, 6, "\\(def$\\)", "abcdef", },
|
||||
{ -1, -1, "\\(abc$\\)", "abcdef", },
|
||||
{ 0, 0, "GA148", NULL, },
|
||||
{ 0, 0, "^$", "", },
|
||||
{ 1, 3, "^abc$", "abc", },
|
||||
{ -1, -1, "^xyz$", "^xyz^", },
|
||||
{ -1, -1, "^234$", "^234$", },
|
||||
{ 1, 9, "^[a-zA-Z0-9]*$", "2aA3bB9zZ", },
|
||||
{ -1, -1, "^[a-z0-9]*$", "2aA3b#B9zZ", },
|
||||
Loaded 100 of 108 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user