Mercurial > jwe > octave

annotate libinterp/corefcn/regexp.cc @ 31120:d8d90ba892b0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
maint: Merge stable to default.
author Markus Mützel <markus.muetzel@gmx.de>
date Mon, 04 Jul 2022 21:36:48 +0200
parents 83f9f8bda883 5cf18ef0377c
children 7d3bda173b63
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
27928
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
1 ////////////////////////////////////////////////////////////////////////
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
2 //
30569
796f54d4ddbf update Octave Project Developers copyright for the new year
John W. Eaton <jwe@octave.org>
parents: 29966
diff changeset
3 // Copyright (C) 2002-2022 The Octave Project Developers
27928
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
4 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
5 // See the file COPYRIGHT.md in the top-level directory of this
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
6 // distribution or <https://octave.org/copyright/>.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
7 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
8 // This file is part of Octave.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
9 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
10 // Octave is free software: you can redistribute it and/or modify it
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
11 // under the terms of the GNU General Public License as published by
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
12 // the Free Software Foundation, either version 3 of the License, or
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
13 // (at your option) any later version.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
14 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
15 // Octave is distributed in the hope that it will be useful, but
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
16 // WITHOUT ANY WARRANTY; without even the implied warranty of
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
18 // GNU General Public License for more details.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
19 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
20 // You should have received a copy of the GNU General Public License
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
21 // along with Octave; see the file COPYING. If not, see
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
22 // <https://www.gnu.org/licenses/>.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
23 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27924
diff changeset
24 ////////////////////////////////////////////////////////////////////////
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
25
21724
aba2e6293dd8 use "#if ..." consistently instead of "#ifdef" and "#ifndef"
John W. Eaton <jwe@octave.org>
parents: 21575
diff changeset
26 #if defined (HAVE_CONFIG_H)
21301
40de9f8f23a6 Use '#include "config.h"' rather than <config.h>.
Rik <rik@octave.org>
parents: 21200
diff changeset
27 # include "config.h"
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
28 #endif
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
29
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
30 #include <list>
5765
7ba9ad1fec11 [project @ 2006-04-17 05:05:15 by jwe]
jwe
parents: 5760
diff changeset
31 #include <sstream>
7ba9ad1fec11 [project @ 2006-04-17 05:05:15 by jwe]
jwe
parents: 5760
diff changeset
32
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
33 #include <pcre.h>
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
34
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
35 #include "base-list.h"
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
36 #include "oct-locbuf.h"
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
37 #include "quit.h"
16940
99122191d3dd maint: Rename regexp.h to lo-regexp.h, regexp.cc to lo-regexp.cc in liboctave.
Rik <rik@octave.org>
parents: 16919
diff changeset
38 #include "lo-regexp.h"
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
39 #include "str-vec.h"
8093
dcc31f473596 Treat PCRE lookbehind operators in a manner that is approximately correct
David Bateman <dbateman@free.fr>
parents: 8021
diff changeset
40
15039
e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents: 14854
diff changeset
41 #include "defun.h"
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
42 #include "Cell.h"
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
43 #include "error.h"
21100
e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme.
Rik <rik@octave.org>
parents: 21055
diff changeset
44 #include "errwarn.h"
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
45 #include "oct-map.h"
20940
48b2ad5ee801 maint: Rename oct-obj.[cc|h] to ovl.[cc|h] for clarity.
Rik <rik@octave.org>
parents: 20939
diff changeset
46 #include "ovl.h"
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
47 #include "utils.h"
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
48
29963
32c3a5805893 move DEFUN and DEFMETHOD functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29660
diff changeset
49 OCTAVE_NAMESPACE_BEGIN
32c3a5805893 move DEFUN and DEFMETHOD functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29660
diff changeset
50
14543
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
51 // Replace backslash escapes in a string with the real values. We need
15541
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
52 // two special functions instead of the one in utils.cc because the set
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
53 // of escape sequences used for regexp patterns and replacement strings
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
54 // is different from those used in the *printf functions.
14543
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
55
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
56 static std::string
22722
e6fac42c8d56 Fix regexp handling of beginning/end word match for double-quoted pattern strings (bug #49451).
Rik <rik@octave.org>
parents: 22599
diff changeset
57 do_regexp_ptn_string_escapes (const std::string& s, bool is_sq_str)
14543
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
58 {
27570
74173f04d2a3 Use syntax for UTF-8 mode with PCRE that is used in the configure test (bug #35910).
Markus Mützel <markus.muetzel@gmx.de>
parents: 27542
diff changeset
59 std::string retval;
14543
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
60
29659
d13d090cb03a use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents: 29363
diff changeset
61 std::size_t i = 0;
d13d090cb03a use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents: 29363
diff changeset
62 std::size_t j = 0;
d13d090cb03a use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents: 29363
diff changeset
63 std::size_t len = s.length ();
14543
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
64
29350
8f0d0d4690c0 Change regexp start-of-word/end-of-word behavior for Matlab compatiblity (bug #59992).
Rik <rik@octave.org>
parents: 29122
diff changeset
65 retval.resize (len);
14543
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
66
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
67 while (j < len)
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
68 {
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
69 if (s[j] == '\\' && j+1 < len)
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
70 {
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
71 switch (s[++j])
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
72 {
15541
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
73 case 'b': // backspace
22722
e6fac42c8d56 Fix regexp handling of beginning/end word match for double-quoted pattern strings (bug #49451).
Rik <rik@octave.org>
parents: 22599
diff changeset
74 if (is_sq_str)
e6fac42c8d56 Fix regexp handling of beginning/end word match for double-quoted pattern strings (bug #49451).
Rik <rik@octave.org>
parents: 22599
diff changeset
75 retval[i] = '\b';
e6fac42c8d56 Fix regexp handling of beginning/end word match for double-quoted pattern strings (bug #49451).
Rik <rik@octave.org>
parents: 22599
diff changeset
76 else
e6fac42c8d56 Fix regexp handling of beginning/end word match for double-quoted pattern strings (bug #49451).
Rik <rik@octave.org>
parents: 22599
diff changeset
77 {
e6fac42c8d56 Fix regexp handling of beginning/end word match for double-quoted pattern strings (bug #49451).
Rik <rik@octave.org>
parents: 22599
diff changeset
78 // Pass escape sequence through
e6fac42c8d56 Fix regexp handling of beginning/end word match for double-quoted pattern strings (bug #49451).
Rik <rik@octave.org>
parents: 22599
diff changeset
79 retval[i] = '\\';
e6fac42c8d56 Fix regexp handling of beginning/end word match for double-quoted pattern strings (bug #49451).
Rik <rik@octave.org>
parents: 22599
diff changeset
80 retval[++i] = 'b';
e6fac42c8d56 Fix regexp handling of beginning/end word match for double-quoted pattern strings (bug #49451).
Rik <rik@octave.org>
parents: 22599
diff changeset
81 }
14543
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
82 break;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
83
29350
8f0d0d4690c0 Change regexp start-of-word/end-of-word behavior for Matlab compatiblity (bug #59992).
Rik <rik@octave.org>
parents: 29122
diff changeset
84 // Translate \< and \> to PCRE patterns for pseudo-word boundary
16918
ab46b5c77669 Fix word boundary handling in regexp pattern (bug #38778)
Mike Miller <mtmiller@ieee.org>
parents: 16816
diff changeset
85 case '<': // begin word boundary
29350
8f0d0d4690c0 Change regexp start-of-word/end-of-word behavior for Matlab compatiblity (bug #59992).
Rik <rik@octave.org>
parents: 29122
diff changeset
86 retval.insert (i, "(?<=\\W|^)");
8f0d0d4690c0 Change regexp start-of-word/end-of-word behavior for Matlab compatiblity (bug #59992).
Rik <rik@octave.org>
parents: 29122
diff changeset
87 i += 8;
8f0d0d4690c0 Change regexp start-of-word/end-of-word behavior for Matlab compatiblity (bug #59992).
Rik <rik@octave.org>
parents: 29122
diff changeset
88 break;
8f0d0d4690c0 Change regexp start-of-word/end-of-word behavior for Matlab compatiblity (bug #59992).
Rik <rik@octave.org>
parents: 29122
diff changeset
89
16918
ab46b5c77669 Fix word boundary handling in regexp pattern (bug #38778)
Mike Miller <mtmiller@ieee.org>
parents: 16816
diff changeset
90 case '>': // end word boundary
29350
8f0d0d4690c0 Change regexp start-of-word/end-of-word behavior for Matlab compatiblity (bug #59992).
Rik <rik@octave.org>
parents: 29122
diff changeset
91 retval.insert (i, "(?=\\W|$)");
8f0d0d4690c0 Change regexp start-of-word/end-of-word behavior for Matlab compatiblity (bug #59992).
Rik <rik@octave.org>
parents: 29122
diff changeset
92 i += 7;
16918
ab46b5c77669 Fix word boundary handling in regexp pattern (bug #38778)
Mike Miller <mtmiller@ieee.org>
parents: 16816
diff changeset
93 break;
ab46b5c77669 Fix word boundary handling in regexp pattern (bug #38778)
Mike Miller <mtmiller@ieee.org>
parents: 16816
diff changeset
94
20211
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
95 case 'o': // octal input
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
96 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
97 bool bad_esc_seq = (j+1 >= len);
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
98
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
99 bool brace = false;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
100 if (! bad_esc_seq && s[++j] == '{')
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
101 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
102 brace = true;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
103 j++;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
104 }
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
105
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
106 int tmpi = 0;
29659
d13d090cb03a use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents: 29363
diff changeset
107 std::size_t k;
20211
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
108 for (k = j; k < std::min (j+3+brace, len); k++)
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
109 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
110 int digit = s[k] - '0';
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
111 if (digit < 0 || digit > 7)
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
112 break;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
113 tmpi <<= 3;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
114 tmpi += digit;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
115 }
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
116 if (bad_esc_seq || (brace && s[k++] != '}'))
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
117 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
118 tmpi = 0;
23804
8057d3f0673d Use C++11 raw string literals to avoid escaping backslashes in strings.
Rik <rik@octave.org>
parents: 23777
diff changeset
119 warning (R"(malformed octal escape sequence '\o' -- converting to '\0')");
20211
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
120 }
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
121 retval[i] = tmpi;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
122 j = k - 1;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
123 break;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
124 }
15541
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
125
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
126 default: // pass escape sequence through
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
127 retval[i] = '\\';
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
128 retval[++i] = s[j];
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
129 break;
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
130 }
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
131 }
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
132 else
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
133 {
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
134 retval[i] = s[j];
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
135 }
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
136
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
137 i++;
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
138 j++;
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
139 }
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
140
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
141 retval.resize (i);
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
142
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
143 return retval;
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
144 }
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
145
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
146 static std::string
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
147 do_regexp_rep_string_escapes (const std::string& s)
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
148 {
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
149 std::string retval;
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
150
29659
d13d090cb03a use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents: 29363
diff changeset
151 std::size_t i = 0;
d13d090cb03a use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents: 29363
diff changeset
152 std::size_t j = 0;
d13d090cb03a use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents: 29363
diff changeset
153 std::size_t len = s.length ();
15541
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
154
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
155 retval.resize (len);
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
156
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
157 while (j < len)
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
158 {
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
159 if (s[j] == '\\' && j+1 < len)
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
160 {
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
161 switch (s[++j])
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
162 {
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
163 case 'a': // alarm
14543
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
164 retval[i] = '\a';
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
165 break;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
166
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
167 case 'b': // backspace
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
168 retval[i] = '\b';
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
169 break;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
170
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
171 case 'f': // formfeed
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
172 retval[i] = '\f';
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
173 break;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
174
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
175 case 'n': // newline
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
176 retval[i] = '\n';
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
177 break;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
178
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
179 case 'r': // carriage return
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
180 retval[i] = '\r';
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
181 break;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
182
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
183 case 't': // horizontal tab
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
184 retval[i] = '\t';
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
185 break;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
186
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
187 case 'v': // vertical tab
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
188 retval[i] = '\v';
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
189 break;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
190
24751
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
191 case '0':
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
192 case '1':
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
193 case '2':
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
194 case '3':
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
195 case '4':
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
196 case '5':
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
197 case '6':
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
198 case '7': // octal input
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
199 {
29659
d13d090cb03a use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents: 29363
diff changeset
200 std::size_t k;
24751
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
201 int tmpi = s[j] - '0';
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
202 for (k = j+1; k < std::min (j+3, len); k++)
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
203 {
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
204 int digit = s[k] - '0';
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
205 if (digit < 0 || digit > 7)
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
206 break;
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
207 tmpi <<= 3;
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
208 tmpi += digit;
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
209 }
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
210 retval[i] = tmpi;
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
211 j = k - 1;
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
212 break;
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
213 }
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
214
20211
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
215 case 'o': // octal input
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
216 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
217 bool bad_esc_seq = (j+1 >= len);
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
218
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
219 bool brace = false;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
220 if (! bad_esc_seq && s[++j] == '{')
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
221 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
222 brace = true;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
223 j++;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
224 }
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
225
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
226 int tmpi = 0;
29659
d13d090cb03a use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents: 29363
diff changeset
227 std::size_t k;
20211
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
228 for (k = j; k < std::min (j+3+brace, len); k++)
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
229 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
230 int digit = s[k] - '0';
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
231 if (digit < 0 || digit > 7)
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
232 break;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
233 tmpi <<= 3;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
234 tmpi += digit;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
235 }
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
236 if (bad_esc_seq || (brace && s[k++] != '}'))
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
237 {
23804
8057d3f0673d Use C++11 raw string literals to avoid escaping backslashes in strings.
Rik <rik@octave.org>
parents: 23777
diff changeset
238 warning (R"(malformed octal escape sequence '\o' -- converting to '\0')");
20211
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
239 tmpi = 0;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
240 }
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
241 retval[i] = tmpi;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
242 j = k - 1;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
243 break;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
244 }
14543
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
245
20211
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
246 case 'x': // hex input
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
247 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
248 bool bad_esc_seq = (j+1 >= len);
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
249
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
250 bool brace = false;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
251 if (! bad_esc_seq && s[++j] == '{')
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
252 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
253 brace = true;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
254 j++;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
255 }
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
256
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
257 int tmpi = 0;
29659
d13d090cb03a use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents: 29363
diff changeset
258 std::size_t k;
20211
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
259 for (k = j; k < std::min (j+2+brace, len); k++)
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
260 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
261 if (! isxdigit (s[k]))
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
262 break;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
263
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
264 tmpi <<= 4;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
265 int digit = s[k];
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
266 if (digit >= 'a')
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
267 tmpi += digit - 'a' + 10;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
268 else if (digit >= 'A')
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
269 tmpi += digit - 'A' + 10;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
270 else
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
271 tmpi += digit - '0';
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
272 }
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
273 if (bad_esc_seq || (brace && s[k++] != '}'))
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
274 {
23804
8057d3f0673d Use C++11 raw string literals to avoid escaping backslashes in strings.
Rik <rik@octave.org>
parents: 23777
diff changeset
275 warning (R"(malformed hex escape sequence '\x' -- converting to '\0')");
20211
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
276 tmpi = 0;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
277 }
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
278 retval[i] = tmpi;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
279 j = k - 1;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
280 break;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp.
Rik <rik@octave.org>
parents: 20172
diff changeset
281 }
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
282
20290
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
283 // Both dollar sign (for capture buffer) and backslash are
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
284 // passed through with their escape backslash. The processing
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
285 // for these must occur during the actual replacement operation
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
286 // in lo-regexp.cc.
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
287 case '$': // pass dollar sign through with escape
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
288 retval[i] = '\\'; retval[++i] = '$';
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
289 break;
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
290
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
291 case '\\': // pass backslash through with escape
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
292 retval[i] = '\\'; retval[++i] = '\\';
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
293 break;
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
294
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
295 default: // convert escaped character to unescaped char
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
296 retval[i] = s[j];
14543
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
297 break;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
298 }
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
299 }
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
300 else
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
301 {
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
302 retval[i] = s[j];
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
303 }
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
304
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
305 i++;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
306 j++;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
307 }
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
308
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
309 retval.resize (i);
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
310
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
311 return retval;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
312 }
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
313
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
314 static void
29966
7d6709900da7 eliminate octave:: namespace tags in DEFUN and DEFMETHOD and more
John W. Eaton <jwe@octave.org>
parents: 29963
diff changeset
315 parse_options (regexp::opts& options, const octave_value_list& args,
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
316 const std::string& who, int skip, bool& extra_args)
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
317 {
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
318 extra_args = false;
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
319
20819
f428cbe7576f eliminate unnecessary uses of nargin
John W. Eaton <jwe@octave.org>
parents: 20801
diff changeset
320 for (int i = skip; i < args.length (); i++)
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
321 {
19403
03067dab10ca Use stricter input validation when looking for a string as input (bug #42651).
Rik <rik@octave.org>
parents: 17861
diff changeset
322 std::string str;
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
323
20700
68e3a747ca02 rename octave_value value extractors that accept error message args
John W. Eaton <jwe@octave.org>
parents: 20581
diff changeset
324 str = args(i).xstring_value ("%s: optional arguments must be strings", who.c_str ());
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
325
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
326 std::transform (str.begin (), str.end (), str.begin (), tolower);
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
327
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
328 if (str.find ("once", 0) == 0)
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
329 options.once (true);
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
330 else if (str.find ("matchcase", 0) == 0)
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
331 options.case_insensitive (false);
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
332 else if (str.find ("ignorecase", 0) == 0)
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
333 options.case_insensitive (true);
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
334 else if (str.find ("dotall", 0) == 0)
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
335 options.dotexceptnewline (false);
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
336 else if (str.find ("stringanchors", 0) == 0)
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
337 options.lineanchors (false);
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
338 else if (str.find ("literalspacing", 0) == 0)
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
339 options.freespacing (false);
14536
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
340 else if (str.find ("noemptymatch", 0) == 0)
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
341 options.emptymatch (false);
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
342 else if (str.find ("dotexceptnewline", 0) == 0)
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
343 options.dotexceptnewline (true);
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
344 else if (str.find ("lineanchors", 0) == 0)
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
345 options.lineanchors (true);
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
346 else if (str.find ("freespacing", 0) == 0)
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
347 options.freespacing (true);
14536
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
348 else if (str.find ("emptymatch", 0) == 0)
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
349 options.emptymatch (true);
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
350 else if (str.find ("start", 0) == 0
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
351 || str.find ("end", 0) == 0
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
352 || str.find ("tokenextents", 0) == 0
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
353 || str.find ("match", 0) == 0
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
354 || str.find ("tokens", 0) == 0
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
355 || str.find ("names", 0) == 0
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
356 || str.find ("split", 0) == 0)
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
357 extra_args = true;
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
358 else
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
359 error ("%s: unrecognized option", who.c_str ());
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
360 }
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
361 }
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
362
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
363 static octave_value_list
23433
c9fab0bc983e maint: Use convention 'int& x' for naming references.
Rik <rik@octave.org>
parents: 23220
diff changeset
364 octregexp (const octave_value_list& args, int nargout,
c9fab0bc983e maint: Use convention 'int& x' for naming references.
Rik <rik@octave.org>
parents: 23220
diff changeset
365 const std::string& who, bool case_insensitive = false)
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
366 {
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
367 octave_value_list retval;
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
368
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
369 int nargin = args.length ();
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
370
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
371 // Make sure we have string, pattern
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
372 const std::string buffer = args(0).string_value ();
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
373
14543
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
374 std::string pattern = args(1).string_value ();
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
375
22722
e6fac42c8d56 Fix regexp handling of beginning/end word match for double-quoted pattern strings (bug #49451).
Rik <rik@octave.org>
parents: 22599
diff changeset
376 // Rewrite pattern for PCRE
e6fac42c8d56 Fix regexp handling of beginning/end word match for double-quoted pattern strings (bug #49451).
Rik <rik@octave.org>
parents: 22599
diff changeset
377 pattern = do_regexp_ptn_string_escapes (pattern, args(1).is_sq_string ());
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
378
29966
7d6709900da7 eliminate octave:: namespace tags in DEFUN and DEFMETHOD and more
John W. Eaton <jwe@octave.org>
parents: 29963
diff changeset
379 regexp::opts options;
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
380 options.case_insensitive (case_insensitive);
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
381 bool extra_options = false;
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
382 parse_options (options, args, who, 2, extra_options);
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
383
29966
7d6709900da7 eliminate octave:: namespace tags in DEFUN and DEFMETHOD and more
John W. Eaton <jwe@octave.org>
parents: 29963
diff changeset
384 const regexp::match_data rx_lst
7d6709900da7 eliminate octave:: namespace tags in DEFUN and DEFMETHOD and more
John W. Eaton <jwe@octave.org>
parents: 29963
diff changeset
385 = regexp::match (pattern, buffer, options, who);
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
386
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
387 string_vector named_pats = rx_lst.named_patterns ();
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
388
29659
d13d090cb03a use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents: 29363
diff changeset
389 std::size_t sz = rx_lst.size ();
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
390
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
391 // Converted the linked list in the correct form for the return values
12464
dfeea9cae79e require PCRE to build Octave
John W. Eaton <jwe@octave.org>
parents: 12462
diff changeset
392
23019
cb09392b5b1c Return struct array for 'names' option of regexp (bug #49659).
Rik <rik@octave.org>
parents: 22862
diff changeset
393 octave_map nmap (dim_vector ((sz == 0 ? 0 : 1), sz), named_pats);
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
394
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
395 retval.resize (7);
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
396
23019
cb09392b5b1c Return struct array for 'names' option of regexp (bug #49659).
Rik <rik@octave.org>
parents: 22862
diff changeset
397 if (sz != 0)
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
398 {
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
399 for (int j = 0; j < named_pats.numel (); j++)
7893
eb9ccb44ea41 make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 7520
diff changeset
400 {
23019
cb09392b5b1c Return struct array for 'names' option of regexp (bug #49659).
Rik <rik@octave.org>
parents: 22862
diff changeset
401 Cell ctmp (dim_vector (1, sz));
cb09392b5b1c Return struct array for 'names' option of regexp (bug #49659).
Rik <rik@octave.org>
parents: 22862
diff changeset
402 octave_idx_type i = 0;
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
403
22862
e365e87371a3 maint: Use C++ range feature to simplify some for loops in libinterp/corefcn.
Rik <rik@octave.org>
parents: 22755
diff changeset
404 for (const auto& match_data : rx_lst)
13310
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
405 {
22862
e365e87371a3 maint: Use C++ range feature to simplify some for loops in libinterp/corefcn.
Rik <rik@octave.org>
parents: 22755
diff changeset
406 string_vector named_tokens = match_data.named_tokens ();
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
407
23019
cb09392b5b1c Return struct array for 'names' option of regexp (bug #49659).
Rik <rik@octave.org>
parents: 22862
diff changeset
408 ctmp(i++) = named_tokens(j);
13310
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
409 }
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
410
23019
cb09392b5b1c Return struct array for 'names' option of regexp (bug #49659).
Rik <rik@octave.org>
parents: 22862
diff changeset
411 nmap.assign (named_pats(j), ctmp);
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
412 }
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
413 }
23019
cb09392b5b1c Return struct array for 'names' option of regexp (bug #49659).
Rik <rik@octave.org>
parents: 22862
diff changeset
414 retval(5) = nmap;
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
415
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
416 if (options.once ())
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
417 {
25337
3ff9192b676e use auto keyword to declare iterator variables where possible
John W. Eaton <jwe@octave.org>
parents: 25054
diff changeset
418 auto p = rx_lst.begin ();
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
419
23450
855122b993da maint: Wrap tertiary operator in parentheses "(COND ? x : y)".
Rik <rik@octave.org>
parents: 23433
diff changeset
420 retval(4) = (sz ? p->tokens () : Cell ());
855122b993da maint: Wrap tertiary operator in parentheses "(COND ? x : y)".
Rik <rik@octave.org>
parents: 23433
diff changeset
421 retval(3) = (sz ? p->match_string () : "");
855122b993da maint: Wrap tertiary operator in parentheses "(COND ? x : y)".
Rik <rik@octave.org>
parents: 23433
diff changeset
422 retval(2) = (sz ? p->token_extents () : Matrix ());
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
423
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
424 if (sz)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
425 {
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
426 double start = p->start ();
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
427 double end = p->end ();
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
428
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
429 Cell split (dim_vector (1, 2));
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
430 split(0) = buffer.substr (0, start-1);
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
431 split(1) = buffer.substr (end);
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
432
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
433 retval(6) = split;
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
434 retval(1) = end;
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
435 retval(0) = start;
7893
eb9ccb44ea41 make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 7520
diff changeset
436 }
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
437 else
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
438 {
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
439 retval(6) = buffer;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
440 retval(1) = Matrix ();
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
441 retval(0) = Matrix ();
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
442 }
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
443 }
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
444 else
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
445 {
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
446 Cell tokens (dim_vector (1, sz));
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
447 Cell match_string (dim_vector (1, sz));
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
448 Cell token_extents (dim_vector (1, sz));
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
449 NDArray end (dim_vector (1, sz));
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
450 NDArray start (dim_vector (1, sz));
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
451 Cell split (dim_vector (1, sz+1));
29659
d13d090cb03a use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents: 29363
diff changeset
452 std::size_t sp_start = 0;
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
453
23019
cb09392b5b1c Return struct array for 'names' option of regexp (bug #49659).
Rik <rik@octave.org>
parents: 22862
diff changeset
454 octave_idx_type i = 0;
22862
e365e87371a3 maint: Use C++ range feature to simplify some for loops in libinterp/corefcn.
Rik <rik@octave.org>
parents: 22755
diff changeset
455 for (const auto& match_data : rx_lst)
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
456 {
22862
e365e87371a3 maint: Use C++ range feature to simplify some for loops in libinterp/corefcn.
Rik <rik@octave.org>
parents: 22755
diff changeset
457 double s = match_data.start ();
e365e87371a3 maint: Use C++ range feature to simplify some for loops in libinterp/corefcn.
Rik <rik@octave.org>
parents: 22755
diff changeset
458 double e = match_data.end ();
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
459
22862
e365e87371a3 maint: Use C++ range feature to simplify some for loops in libinterp/corefcn.
Rik <rik@octave.org>
parents: 22755
diff changeset
460 string_vector tmp = match_data.tokens ();
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
461 tokens(i) = Cell (dim_vector (1, tmp.numel ()), tmp);
22862
e365e87371a3 maint: Use C++ range feature to simplify some for loops in libinterp/corefcn.
Rik <rik@octave.org>
parents: 22755
diff changeset
462 match_string(i) = match_data.match_string ();
e365e87371a3 maint: Use C++ range feature to simplify some for loops in libinterp/corefcn.
Rik <rik@octave.org>
parents: 22755
diff changeset
463 token_extents(i) = match_data.token_extents ();
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
464 end(i) = e;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
465 start(i) = s;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
466 split(i) = buffer.substr (sp_start, s-sp_start-1);
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
467 sp_start = e;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
468 i++;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
469 }
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
470
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
471 split(i) = buffer.substr (sp_start);
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11572
diff changeset
472
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
473 retval(6) = split;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
474 retval(4) = tokens;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
475 retval(3) = match_string;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
476 retval(2) = token_extents;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
477 retval(1) = end;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
478 retval(0) = start;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
479 }
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
480
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
481 // Alter the order of the output arguments
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
482
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
483 if (extra_options)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
484 {
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
485 int n = 0;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
486 octave_value_list new_retval;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
487 new_retval.resize (nargout);
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
488
26479
54ad1294ed70 regexp.cc: Fix static analyzer detected issues (bug #55347).
Rik <rik@octave.org>
parents: 26379
diff changeset
489 bool arg_used[7] {};
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
490
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
491 for (int j = 2; j < nargin; j++)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
492 {
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
493 int k = 0;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
494 std::string str = args(j).string_value ();
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
495 std::transform (str.begin (), str.end (), str.begin (), tolower);
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
496
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
497 if (str.find ("once", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
498 || str.find ("stringanchors", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
499 || str.find ("lineanchors", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
500 || str.find ("matchcase", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
501 || str.find ("ignorecase", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
502 || str.find ("dotall", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
503 || str.find ("dotexceptnewline", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
504 || str.find ("literalspacing", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
505 || str.find ("freespacing", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
506 || str.find ("noemptymatch", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
507 || str.find ("emptymatch", 0) == 0)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
508 continue;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
509 else if (str.find ("start", 0) == 0)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
510 k = 0;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
511 else if (str.find ("end", 0) == 0)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
512 k = 1;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
513 else if (str.find ("tokenextents", 0) == 0)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
514 k = 2;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
515 else if (str.find ("match", 0) == 0)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
516 k = 3;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
517 else if (str.find ("tokens", 0) == 0)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
518 k = 4;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
519 else if (str.find ("names", 0) == 0)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
520 k = 5;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
521 else if (str.find ("split", 0) == 0)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
522 k = 6;
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
523
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
524 new_retval(n++) = retval(k);
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
525 arg_used[k] = true;
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
526
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
527 if (n == nargout)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
528 break;
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
529 }
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
530
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
531 // Fill in the rest of the arguments
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
532 if (n < nargout)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
533 {
23769
fdce2b73f5ce regexp.cc: Correctly size temporary buffer to avoid segfault when re-arranging outputs.
Rik <rik@octave.org>
parents: 23219
diff changeset
534 for (int j = 0; j < 7; j++)
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
535 {
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
536 if (! arg_used[j])
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
537 new_retval(n++) = retval(j);
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
538 }
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
539 }
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
540
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
541 retval = new_retval;
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
542 }
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
543
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
544 return retval;
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
545 }
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
546
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
547 static octave_value_list
23433
c9fab0bc983e maint: Use convention 'int& x' for naming references.
Rik <rik@octave.org>
parents: 23220
diff changeset
548 octcellregexp (const octave_value_list& args, int nargout,
c9fab0bc983e maint: Use convention 'int& x' for naming references.
Rik <rik@octave.org>
parents: 23220
diff changeset
549 const std::string& who, bool case_insensitive = false)
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
550 {
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
551 octave_value_list retval;
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
552
23576
00e518162fda maint: Deprecate is_cell and replace with iscell.
Rik <rik@octave.org>
parents: 23573
diff changeset
553 if (args(0).iscell ())
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
554 {
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
555 OCTAVE_LOCAL_BUFFER (Cell, newretval, nargout);
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
556 octave_value_list new_args = args;
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
557 Cell cellstr = args(0).cell_value ();
23576
00e518162fda maint: Deprecate is_cell and replace with iscell.
Rik <rik@octave.org>
parents: 23573
diff changeset
558 if (args(1).iscell ())
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
559 {
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
560 Cell cellpat = args(1).cell_value ();
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
561
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
562 if (cellpat.numel () == 1)
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
563 {
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
564 for (int j = 0; j < nargout; j++)
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
565 newretval[j].resize (cellstr.dims ());
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
566
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
567 new_args(1) = cellpat(0);
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
568
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
569 for (octave_idx_type i = 0; i < cellstr.numel (); i++)
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
570 {
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
571 new_args(0) = cellstr(i);
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
572 octave_value_list tmp = octregexp (new_args, nargout, who,
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
573 case_insensitive);
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
574
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
575 for (int j = 0; j < nargout; j++)
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
576 newretval[j](i) = tmp(j);
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
577 }
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
578 }
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
579 else if (cellstr.numel () == 1)
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
580 {
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
581 for (int j = 0; j < nargout; j++)
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
582 newretval[j].resize (cellpat.dims ());
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
583
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
584 new_args(0) = cellstr(0);
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
585
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
586 for (octave_idx_type i = 0; i < cellpat.numel (); i++)
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
587 {
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
588 new_args(1) = cellpat(i);
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
589 octave_value_list tmp = octregexp (new_args, nargout, who,
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
590 case_insensitive);
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
591
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
592 for (int j = 0; j < nargout; j++)
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
593 newretval[j](i) = tmp(j);
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
594 }
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
595 }
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
596 else if (cellstr.numel () == cellpat.numel ())
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
597 {
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
598 if (cellstr.dims () != cellpat.dims ())
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
599 error ("%s: inconsistent cell array dimensions", who.c_str ());
21055
5e00ed38a58b maint: Replace if/error/else paradigm with just if/error.
Rik <rik@octave.org>
parents: 21017
diff changeset
600
5e00ed38a58b maint: Replace if/error/else paradigm with just if/error.
Rik <rik@octave.org>
parents: 21017
diff changeset
601 for (int j = 0; j < nargout; j++)
5e00ed38a58b maint: Replace if/error/else paradigm with just if/error.
Rik <rik@octave.org>
parents: 21017
diff changeset
602 newretval[j].resize (cellstr.dims ());
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
603
21055
5e00ed38a58b maint: Replace if/error/else paradigm with just if/error.
Rik <rik@octave.org>
parents: 21017
diff changeset
604 for (octave_idx_type i = 0; i < cellstr.numel (); i++)
5e00ed38a58b maint: Replace if/error/else paradigm with just if/error.
Rik <rik@octave.org>
parents: 21017
diff changeset
605 {
5e00ed38a58b maint: Replace if/error/else paradigm with just if/error.
Rik <rik@octave.org>
parents: 21017
diff changeset
606 new_args(0) = cellstr(i);
5e00ed38a58b maint: Replace if/error/else paradigm with just if/error.
Rik <rik@octave.org>
parents: 21017
diff changeset
607 new_args(1) = cellpat(i);
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
608
21055
5e00ed38a58b maint: Replace if/error/else paradigm with just if/error.
Rik <rik@octave.org>
parents: 21017
diff changeset
609 octave_value_list tmp = octregexp (new_args, nargout, who,
5e00ed38a58b maint: Replace if/error/else paradigm with just if/error.
Rik <rik@octave.org>
parents: 21017
diff changeset
610 case_insensitive);
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
611
21055
5e00ed38a58b maint: Replace if/error/else paradigm with just if/error.
Rik <rik@octave.org>
parents: 21017
diff changeset
612 for (int j = 0; j < nargout; j++)
5e00ed38a58b maint: Replace if/error/else paradigm with just if/error.
Rik <rik@octave.org>
parents: 21017
diff changeset
613 newretval[j](i) = tmp(j);
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
614 }
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
615 }
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
616 else
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
617 error ("regexp: cell array arguments must be scalar or equal size");
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
618 }
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
619 else
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
620 {
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
621 for (int j = 0; j < nargout; j++)
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
622 newretval[j].resize (cellstr.dims ());
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
623
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
624 for (octave_idx_type i = 0; i < cellstr.numel (); i++)
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
625 {
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
626 new_args(0) = cellstr(i);
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
627 octave_value_list tmp = octregexp (new_args, nargout, who,
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
628 case_insensitive);
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
629
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
630 for (int j = 0; j < nargout; j++)
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
631 newretval[j](i) = tmp(j);
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
632 }
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
633 }
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
634
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
635 for (int j = 0; j < nargout; j++)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
636 retval(j) = octave_value (newretval[j]);
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
637 }
23576
00e518162fda maint: Deprecate is_cell and replace with iscell.
Rik <rik@octave.org>
parents: 23573
diff changeset
638 else if (args(1).iscell ())
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
639 {
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
640 OCTAVE_LOCAL_BUFFER (Cell, newretval, nargout);
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
641 octave_value_list new_args = args;
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
642 Cell cellpat = args(1).cell_value ();
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
643
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
644 for (int j = 0; j < nargout; j++)
14854
5ae9f0f77635 maint: Use Octave coding conventions for coddling parenthis is DLD-FUNCTIONS directory
Rik <octave@nomad.inbox5.com>
parents: 14846
diff changeset
645 newretval[j].resize (cellpat.dims ());
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
646
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
647 for (octave_idx_type i = 0; i < cellpat.numel (); i++)
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
648 {
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
649 new_args(1) = cellpat(i);
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
650 octave_value_list tmp = octregexp (new_args, nargout, who,
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
651 case_insensitive);
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
652
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
653 for (int j = 0; j < nargout; j++)
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
654 newretval[j](i) = tmp(j);
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
655 }
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
656
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
657 for (int j = 0; j < nargout; j++)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
658 retval(j) = octave_value (newretval[j]);
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
659 }
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
660 else
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
661 retval = octregexp (args, nargout, who, case_insensitive);
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
662
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
663 return retval;
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
664
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
665 }
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
666
15039
e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents: 14854
diff changeset
667 DEFUN (regexp, args, nargout,
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
668 doc: /* -*- texinfo -*-
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
669 @deftypefn {} {[@var{s}, @var{e}, @var{te}, @var{m}, @var{t}, @var{nm}, @var{sp}] =} regexp (@var{str}, @var{pat})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
670 @deftypefnx {} {[@dots{}] =} regexp (@var{str}, @var{pat}, "@var{opt1}", @dots{})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
671 Regular expression string matching.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
672
27542
7dc31256c5e4 Document that regexp* functions need UTF-8 encoded input (bug #35910).
Markus Mützel <markus.muetzel@gmx.de>
parents: 27282
diff changeset
673 Search for @var{pat} in UTF-8 encoded @var{str} and return the positions and
7dc31256c5e4 Document that regexp* functions need UTF-8 encoded input (bug #35910).
Markus Mützel <markus.muetzel@gmx.de>
parents: 27282
diff changeset
674 substrings of any matches, or empty values if there are none.
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
675
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
676 The matched pattern @var{pat} can include any of the standard regex
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
677 operators, including:
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
678
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
679 @table @code
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
680 @item .
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
681 Match any character
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
682
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
683 @item * + ? @{@}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
684 Repetition operators, representing
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
685
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
686 @table @code
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
687 @item *
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
688 Match zero or more times
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
689
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
690 @item +
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
691 Match one or more times
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
692
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
693 @item ?
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
694 Match zero or one times
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
695
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
696 @item @{@var{n}@}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
697 Match exactly @var{n} times
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
698
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
699 @item @{@var{n},@}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
700 Match @var{n} or more times
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
701
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
702 @item @{@var{m},@var{n}@}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
703 Match between @var{m} and @var{n} times
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
704 @end table
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
705
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
706 @item [@dots{}] [^@dots{}]
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
707
22299
9fc91bb2aec3 doc: grammarcheck documentation for 4.2 release.
Rik <rik@octave.org>
parents: 22197
diff changeset
708 List operators. The pattern will match any character listed between
9fc91bb2aec3 doc: grammarcheck documentation for 4.2 release.
Rik <rik@octave.org>
parents: 22197
diff changeset
709 @qcode{"["} and @qcode{"]"}. If the first character is @qcode{"^"} then the
9fc91bb2aec3 doc: grammarcheck documentation for 4.2 release.
Rik <rik@octave.org>
parents: 22197
diff changeset
710 pattern is inverted and any character except those listed between brackets
9fc91bb2aec3 doc: grammarcheck documentation for 4.2 release.
Rik <rik@octave.org>
parents: 22197
diff changeset
711 will match.
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
712
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
713 Escape sequences defined below can also be used inside list operators. For
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
714 example, a template for a floating point number might be @code{[-+.\d]+}.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
715
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
716 @item () (?:)
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
717 Grouping operator. The first form, parentheses only, also creates a token.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
718
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
719 @item |
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
720 Alternation operator. Match one of a choice of regular expressions. The
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
721 alternatives must be delimited by the grouping operator @code{()} above.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
722
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
723 @item ^ $
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
724 Anchoring operators. Requires pattern to occur at the start (@code{^}) or
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
725 end (@code{$}) of the string.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
726 @end table
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
727
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
728 In addition, the following escaped characters have special meaning.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
729
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
730 @table @code
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
731
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
732 @item \d
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
733 Match any digit
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
734
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
735 @item \D
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
736 Match any non-digit
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
737
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
738 @item \s
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
739 Match any whitespace character
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
740
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
741 @item \S
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
742 Match any non-whitespace character
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
743
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
744 @item \w
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
745 Match any word character
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
746
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
747 @item \W
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
748 Match any non-word character
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
749
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
750 @item \<
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
751 Match the beginning of a word
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
752
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
753 @item \>
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
754 Match the end of a word
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
755
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
756 @item \B
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
757 Match within a word
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
758 @end table
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
759
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
760 Implementation Note: For compatibility with @sc{matlab}, escape sequences
29122
10a35049bad7 doc: Cleanup Texinfo macros use in documentation.
Rik <rik@octave.org>
parents: 28966
diff changeset
761 in @var{pat} (e.g., @qcode{"@backslashchar{}n"} => newline) are expanded
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
762 even when @var{pat} has been defined with single quotes. To disable
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
763 expansion use a second backslash before the escape sequence (e.g.,
29122
10a35049bad7 doc: Cleanup Texinfo macros use in documentation.
Rik <rik@octave.org>
parents: 28966
diff changeset
764 "@backslashchar{}@backslashchar{}n") or use the @code{regexptranslate}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
765 function.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
766
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
767 The outputs of @code{regexp} default to the order given below
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
768
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
769 @table @var
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
770 @item s
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
771 The start indices of each matching substring
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
772
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
773 @item e
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
774 The end indices of each matching substring
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
775
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
776 @item te
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
777 The extents of each matched token surrounded by @code{(@dots{})} in
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
778 @var{pat}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
779
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
780 @item m
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
781 A cell array of the text of each match
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
782
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
783 @item t
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
784 A cell array of the text of each token matched
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
785
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
786 @item nm
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
787 A structure containing the text of each matched named token, with the name
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
788 being used as the fieldname. A named token is denoted by
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
789 @code{(?<name>@dots{})}.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
790
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
791 @item sp
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
792 A cell array of the text not returned by match, i.e., what remains if you
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
793 split the string based on @var{pat}.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
794 @end table
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
795
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
796 Particular output arguments, or the order of the output arguments, can be
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
797 selected by additional @var{opt} arguments. These are strings and the
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
798 correspondence between the output arguments and the optional argument
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
799 are
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
800
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
801 @multitable @columnfractions 0.2 0.3 0.3 0.2
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
802 @item @tab @qcode{'start'} @tab @var{s} @tab
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
803 @item @tab @qcode{'end'} @tab @var{e} @tab
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
804 @item @tab @qcode{'tokenExtents'} @tab @var{te} @tab
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
805 @item @tab @qcode{'match'} @tab @var{m} @tab
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
806 @item @tab @qcode{'tokens'} @tab @var{t} @tab
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
807 @item @tab @qcode{'names'} @tab @var{nm} @tab
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
808 @item @tab @qcode{'split'} @tab @var{sp} @tab
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
809 @end multitable
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
810
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
811 Additional arguments are summarized below.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
812
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
813 @table @samp
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
814 @item once
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
815 Return only the first occurrence of the pattern.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
816
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
817 @item matchcase
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
818 Make the matching case sensitive. (default)
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
819
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
820 Alternatively, use (?-i) in the pattern.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
821
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
822 @item ignorecase
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
823 Ignore case when matching the pattern to the string.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
824
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
825 Alternatively, use (?i) in the pattern.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
826
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
827 @item stringanchors
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
828 Match the anchor characters at the beginning and end of the string.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
829 (default)
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
830
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
831 Alternatively, use (?-m) in the pattern.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
832
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
833 @item lineanchors
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
834 Match the anchor characters at the beginning and end of the line.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
835
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
836 Alternatively, use (?m) in the pattern.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
837
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
838 @item dotall
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
839 The pattern @code{.} matches all characters including the newline character.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
840 (default)
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
841
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
842 Alternatively, use (?s) in the pattern.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
843
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
844 @item dotexceptnewline
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
845 The pattern @code{.} matches all characters except the newline character.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
846
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
847 Alternatively, use (?-s) in the pattern.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
848
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
849 @item literalspacing
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
850 All characters in the pattern, including whitespace, are significant and are
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
851 used in pattern matching. (default)
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
852
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
853 Alternatively, use (?-x) in the pattern.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
854
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
855 @item freespacing
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
856 The pattern may include arbitrary whitespace and also comments beginning
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
857 with the character @samp{#}.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
858
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
859 Alternatively, use (?x) in the pattern.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
860
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
861 @item noemptymatch
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
862 Zero-length matches are not returned. (default)
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
863
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
864 @item emptymatch
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
865 Return zero-length matches.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
866
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
867 @code{regexp ('a', 'b*', 'emptymatch')} returns @code{[1 2]} because there
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
868 are zero or more @qcode{'b'} characters at positions 1 and end-of-string.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
869
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
870 @end table
24986
0b9e7fcaab91 doc: grammarcheck docstrings in C++ files ahead of 4.4 release.
Rik <rik@octave.org>
parents: 24751
diff changeset
871
23816
d396866fa7d8 Add documentation about PCRE library regexp stack overflow (bug #51589).
Daniel J Sebald <daniel.sebald@ieee.org>
parents: 23769
diff changeset
872 Stack Limitation Note: Pattern searches are done with a recursive function
d396866fa7d8 Add documentation about PCRE library regexp stack overflow (bug #51589).
Daniel J Sebald <daniel.sebald@ieee.org>
parents: 23769
diff changeset
873 which can overflow the program stack when there are a high number of matches.
d396866fa7d8 Add documentation about PCRE library regexp stack overflow (bug #51589).
Daniel J Sebald <daniel.sebald@ieee.org>
parents: 23769
diff changeset
874 For example,
d396866fa7d8 Add documentation about PCRE library regexp stack overflow (bug #51589).
Daniel J Sebald <daniel.sebald@ieee.org>
parents: 23769
diff changeset
875
d396866fa7d8 Add documentation about PCRE library regexp stack overflow (bug #51589).
Daniel J Sebald <daniel.sebald@ieee.org>
parents: 23769
diff changeset
876 @example
d396866fa7d8 Add documentation about PCRE library regexp stack overflow (bug #51589).
Daniel J Sebald <daniel.sebald@ieee.org>
parents: 23769
diff changeset
877 @code{regexp (repmat ('a', 1, 1e5), '(a)+')}
d396866fa7d8 Add documentation about PCRE library regexp stack overflow (bug #51589).
Daniel J Sebald <daniel.sebald@ieee.org>
parents: 23769
diff changeset
878 @end example
d396866fa7d8 Add documentation about PCRE library regexp stack overflow (bug #51589).
Daniel J Sebald <daniel.sebald@ieee.org>
parents: 23769
diff changeset
879
24986
0b9e7fcaab91 doc: grammarcheck docstrings in C++ files ahead of 4.4 release.
Rik <rik@octave.org>
parents: 24751
diff changeset
880 @noindent
23816
d396866fa7d8 Add documentation about PCRE library regexp stack overflow (bug #51589).
Daniel J Sebald <daniel.sebald@ieee.org>
parents: 23769
diff changeset
881 may lead to a segfault. As an alternative, consider constructing pattern
d396866fa7d8 Add documentation about PCRE library regexp stack overflow (bug #51589).
Daniel J Sebald <daniel.sebald@ieee.org>
parents: 23769
diff changeset
882 searches that reduce the number of matches (e.g., by creatively using set
d396866fa7d8 Add documentation about PCRE library regexp stack overflow (bug #51589).
Daniel J Sebald <daniel.sebald@ieee.org>
parents: 23769
diff changeset
883 complement), and then further processing the return variables (now reduced in
d396866fa7d8 Add documentation about PCRE library regexp stack overflow (bug #51589).
Daniel J Sebald <daniel.sebald@ieee.org>
parents: 23769
diff changeset
884 size) with successive @code{regexp} searches.
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
885 @seealso{regexpi, strfind, regexprep}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
886 @end deftypefn */)
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
887 {
20821
b169da150702 Eliminate unnecessary uses of nargin.
Rik <rik@octave.org>
parents: 20819
diff changeset
888 if (args.length () < 2)
b169da150702 Eliminate unnecessary uses of nargin.
Rik <rik@octave.org>
parents: 20819
diff changeset
889 print_usage ();
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
890
20821
b169da150702 Eliminate unnecessary uses of nargin.
Rik <rik@octave.org>
parents: 20819
diff changeset
891 octave_value_list retval;
20801
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20700
diff changeset
892
23576
00e518162fda maint: Deprecate is_cell and replace with iscell.
Rik <rik@octave.org>
parents: 23573
diff changeset
893 if (args(0).iscell () || args(1).iscell ())
23450
855122b993da maint: Wrap tertiary operator in parentheses "(COND ? x : y)".
Rik <rik@octave.org>
parents: 23433
diff changeset
894 retval = (octcellregexp (args, (nargout > 0 ? nargout : 1), "regexp"));
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
895 else
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
896 retval = octregexp (args, nargout, "regexp");
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
897
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
898 return retval;
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
899 }
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
900
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
901 /*
8140
cdd05e46f6c9 Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents: 8093
diff changeset
902 ## PCRE_ERROR_MATCHLIMIT test
cdd05e46f6c9 Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents: 8093
diff changeset
903 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
904 %! s = sprintf ('\t4\n0000\t-0.00\t-0.0000\t4\t-0.00\t-0.0000\t4\n0000\t-0.00\t-0.0000\t0\t-0.00\t-');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
905 %! ws = warning ("query");
8140
cdd05e46f6c9 Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents: 8093
diff changeset
906 %! unwind_protect
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
907 %! warning ("off");
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
908 %! regexp (s, '(\s*-*\d+[.]*\d*\s*)+\n');
8140
cdd05e46f6c9 Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents: 8093
diff changeset
909 %! unwind_protect_cleanup
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
910 %! warning (ws);
8140
cdd05e46f6c9 Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents: 8093
diff changeset
911 %! end_unwind_protect
cdd05e46f6c9 Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents: 8093
diff changeset
912
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
913 ## segfault test
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
914 %!assert (regexp ("abcde", "."), [1,2,3,4,5])
31119
5cf18ef0377c regexp: Check pattern length before accessing it (bug #62704).
Markus Mützel <markus.muetzel@gmx.de>
parents: 30569
diff changeset
915 %!assert <*62704> (regexpi('(', '\(?'), 1)
13759
c4b6ea833fa5 Fix infinite loop with null patterns in regexp (Bug #34101, Bug #33258)
Rik <octave@nomad.inbox5.com>
parents: 13311
diff changeset
916 ## Infinite loop test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
917 %!assert (isempty (regexp ("abcde", "")))
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
918
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
919 ## Check that anchoring of pattern works correctly
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
920 %!assert (regexp ('abcabc', '^abc'), 1)
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
921 %!assert (regexp ('abcabc', 'abc$'), 4)
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
922 %!assert (regexp ('abcabc', '^abc$'), zeros (1,0))
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
923
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
924 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
925 %! [s, e, te, m, t] = regexp (' No Match ', 'f(.*)uck');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
926 %! assert (s, zeros (1,0));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
927 %! assert (e, zeros (1,0));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
928 %! assert (te, cell (1,0));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
929 %! assert (m, cell (1,0));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
930 %! assert (t, cell (1,0));
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
931
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
932 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
933 %! [s, e, te, m, t] = regexp (' FiRetrUck ', 'f(.*)uck');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
934 %! assert (s, zeros (1,0));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
935 %! assert (e, zeros (1,0));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
936 %! assert (te, cell (1,0));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
937 %! assert (m, cell (1,0));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
938 %! assert (t, cell (1,0));
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
939
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
940 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
941 %! [s, e, te, m, t] = regexp (' firetruck ', 'f(.*)uck');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
942 %! assert (s, 2);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
943 %! assert (e, 10);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
944 %! assert (te{1}, [3, 7]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
945 %! assert (m{1}, 'firetruck');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
946 %! assert (t{1}{1}, 'iretr');
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
947
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
948 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
949 %! [s, e, te, m, t] = regexp ('short test string', '\w*r\w*');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
950 %! assert (s, [1, 12]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
951 %! assert (e, [5, 17]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
952 %! assert (size (te), [1, 2]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
953 %! assert (isempty (te{1}));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
954 %! assert (isempty (te{2}));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
955 %! assert (m{1}, 'short');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
956 %! assert (m{2}, 'string');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
957 %! assert (size (t), [1, 2]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
958 %! assert (isempty (t{1}));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
959 %! assert (isempty (t{2}));
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
960
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
961 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
962 %! [s, e, te, m, t] = regexp ('short test string', '\w*r\w*', 'once');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
963 %! assert (s, 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
964 %! assert (e, 5);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
965 %! assert (isempty (te));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
966 %! assert (m, 'short');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
967 %! assert (isempty (t));
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
968
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
969 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
970 %! [m, te, e, s, t] = regexp ('short test string', '\w*r\w*', 'once', 'match', 'tokenExtents', 'end', 'start', 'tokens');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
971 %! assert (s, 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
972 %! assert (e, 5);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
973 %! assert (isempty (te));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
974 %! assert (m, 'short');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
975 %! assert (isempty (t));
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
976
12462
e4dbfe3019b1 Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents: 12433
diff changeset
977 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
978 %! [s, e, te, m, t, nm] = regexp ('short test string', '(?<word1>\w*t)\s*(?<word2>\w*t)');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
979 %! assert (s, 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
980 %! assert (e, 10);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
981 %! assert (size (te), [1, 1]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
982 %! assert (te{1}, [1,5; 7,10]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
983 %! assert (m{1}, 'short test');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
984 %! assert (size (t), [1, 1]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
985 %! assert (t{1}{1}, 'short');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
986 %! assert (t{1}{2}, 'test');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
987 %! assert (size (nm), [1, 1]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
988 %! assert (! isempty (fieldnames (nm)));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
989 %! assert (sort (fieldnames (nm)), {'word1';'word2'});
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
990 %! assert (nm.word1, 'short');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
991 %! assert (nm.word2, 'test');
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
992
12462
e4dbfe3019b1 Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents: 12433
diff changeset
993 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
994 %! [nm, m, te, e, s, t] = regexp ('short test string', '(?<word1>\w*t)\s*(?<word2>\w*t)', 'names', 'match', 'tokenExtents', 'end', 'start', 'tokens');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
995 %! assert (s, 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
996 %! assert (e, 10);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
997 %! assert (size (te), [1, 1]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
998 %! assert (te{1}, [1,5; 7,10]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
999 %! assert (m{1}, 'short test');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1000 %! assert (size (t), [1, 1]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1001 %! assert (t{1}{1}, 'short');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1002 %! assert (t{1}{2}, 'test');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1003 %! assert (size (nm), [1, 1]);
20955
77f5591878bf maint: Use '! expr' rather than '!expr' to conform to coding guidelines.
Rik <rik@octave.org>
parents: 20940
diff changeset
1004 %! assert (! isempty (fieldnames (nm)));
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1005 %! assert (sort (fieldnames (nm)), {'word1';'word2'});
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1006 %! assert (nm.word1, 'short');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1007 %! assert (nm.word2, 'test');
5619
e9112ff172b1 [project @ 2006-02-13 20:05:36 by dbateman]
dbateman
parents: 5582
diff changeset
1008
12462
e4dbfe3019b1 Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents: 12433
diff changeset
1009 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1010 %! [t, nm] = regexp ("John Davis\nRogers, James", '(?<first>\w+)\s+(?<last>\w+)|(?<last>\w+),\s+(?<first>\w+)', 'tokens', 'names');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1011 %! assert (size (t), [1, 2]);
23019
cb09392b5b1c Return struct array for 'names' option of regexp (bug #49659).
Rik <rik@octave.org>
parents: 22862
diff changeset
1012 %! assert (t{1}{1}, "John");
cb09392b5b1c Return struct array for 'names' option of regexp (bug #49659).
Rik <rik@octave.org>
parents: 22862
diff changeset
1013 %! assert (t{1}{2}, "Davis");
cb09392b5b1c Return struct array for 'names' option of regexp (bug #49659).
Rik <rik@octave.org>
parents: 22862
diff changeset
1014 %! assert (t{2}{1}, "Rogers");
cb09392b5b1c Return struct array for 'names' option of regexp (bug #49659).
Rik <rik@octave.org>
parents: 22862
diff changeset
1015 %! assert (t{2}{2}, "James");
cb09392b5b1c Return struct array for 'names' option of regexp (bug #49659).
Rik <rik@octave.org>
parents: 22862
diff changeset
1016 %! assert (size (nm), [1, 2]);
cb09392b5b1c Return struct array for 'names' option of regexp (bug #49659).
Rik <rik@octave.org>
parents: 22862
diff changeset
1017 %! assert (nm(1).first, "John");
cb09392b5b1c Return struct array for 'names' option of regexp (bug #49659).
Rik <rik@octave.org>
parents: 22862
diff changeset
1018 %! assert (nm(1).last, "Davis");
cb09392b5b1c Return struct array for 'names' option of regexp (bug #49659).
Rik <rik@octave.org>
parents: 22862
diff changeset
1019 %! assert (nm(2).first, "James");
cb09392b5b1c Return struct array for 'names' option of regexp (bug #49659).
Rik <rik@octave.org>
parents: 22862
diff changeset
1020 %! assert (nm(2).last, "Rogers");
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1021
24741
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1022 ## Tests for nulls in strings properly matching
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1023 %!test
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1024 %! str = "A\0B\0\0C";
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1025 %! ptn = '(\0+)'; # also test null in single-quote pattern
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1026 %! M = regexp (str, ptn, "match");
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1027 %! assert (size (M), [1, 2]);
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1028 %! assert (double (M{1}), [0]);
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1029 %! assert (double (M{2}), [0, 0]);
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1030
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1031 %!test
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1032 %! str = "A\0B\0\0C";
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1033 %! ptn = "(\0+)"; # also test null in double-quote pattern
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1034 %! T = regexp (str, ptn, "tokens");
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1035 %! assert (size (T), [1, 2]);
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1036 %! assert (double (T{1}{1}), [0]);
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1037 %! assert (double (T{2}{1}), [0, 0]);
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1038
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1039 %!test
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1040 %! str = "A\0B\0\0C";
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1041 %! ptn = '(?<namedtoken>\0+)';
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1042 %! NT = regexp (str, ptn, "names");
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1043 %! assert (size (NT), [1, 2]);
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1044 %! assert (double (NT(1).namedtoken), [0]);
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1045 %! assert (double (NT(2).namedtoken), [0, 0]);
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1046
14452
721be41ea988 Stop segfault when using regular expressions with named capture buffers (bug #35683).
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1047 ## Tests for named tokens
12462
e4dbfe3019b1 Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents: 12433
diff changeset
1048 %!test
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
1049 %! ## Parenthesis in named token (ie (int)) causes a problem
24741
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1050 %! assert (regexp ('qwe int asd', ['(?<typestr>(int))'], 'names'),
00dfa167c1fe Fix handling of NULL character in regular expressions for Matlab compatibility.
Rik <rik@octave.org>
parents: 24607
diff changeset
1051 %! struct ('typestr', 'int'));
10518
fcafe0e9bd58 Handle repeated matches in matches returned by pcre
David Bateman <dbateman@free.fr>
parents: 10504
diff changeset
1052
23573
1b4f4ec53b4a use new script to tag fixed bugs in tests
John W. Eaton <jwe@octave.org>
parents: 23572
diff changeset
1053 %!test <*35683>
22489
93ea313301f9 test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents: 22407
diff changeset
1054 %! ## Mix of named and unnamed tokens can cause segfault
14452
721be41ea988 Stop segfault when using regular expressions with named capture buffers (bug #35683).
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1055 %! str = "abcde";
721be41ea988 Stop segfault when using regular expressions with named capture buffers (bug #35683).
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1056 %! ptn = '(?<T1>a)(\w+)(?<T2>d\w+)';
721be41ea988 Stop segfault when using regular expressions with named capture buffers (bug #35683).
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1057 %! tokens = regexp (str, ptn, "names");
721be41ea988 Stop segfault when using regular expressions with named capture buffers (bug #35683).
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1058 %! assert (isstruct (tokens) && numel (tokens) == 1);
721be41ea988 Stop segfault when using regular expressions with named capture buffers (bug #35683).
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1059 %! assert (tokens.T1, "a");
721be41ea988 Stop segfault when using regular expressions with named capture buffers (bug #35683).
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1060 %! assert (tokens.T2, "de");
721be41ea988 Stop segfault when using regular expressions with named capture buffers (bug #35683).
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1061
24751
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1062 ## Test options to regexp
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1063 %!assert (regexp ("abc\nabc", '.'), [1:7])
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1064 %!assert (regexp ("abc\nabc", '.', 'dotall'), [1:7])
12462
e4dbfe3019b1 Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents: 12433
diff changeset
1065 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1066 %! assert (regexp ("abc\nabc", '(?s).'), [1:7]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1067 %! assert (regexp ("abc\nabc", '.', 'dotexceptnewline'), [1,2,3,5,6,7]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1068 %! assert (regexp ("abc\nabc", '(?-s).'), [1,2,3,5,6,7]);
5779
12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman]
dbateman
parents: 5775
diff changeset
1069
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1070 %!assert (regexp ("caseCaSe", 'case'), 1)
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1071 %!assert (regexp ("caseCaSe", 'case', "matchcase"), 1)
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1072 %!assert (regexp ("caseCaSe", 'case', "ignorecase"), [1,5])
12462
e4dbfe3019b1 Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents: 12433
diff changeset
1073 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1074 %! assert (regexp ("caseCaSe", '(?-i)case'), 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1075 %! assert (regexp ("caseCaSe", '(?i)case'), [1, 5]);
5779
12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman]
dbateman
parents: 5775
diff changeset
1076
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1077 %!assert (regexp ("abc\nabc", 'c$'), 7)
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1078 %!assert (regexp ("abc\nabc", 'c$', "stringanchors"), 7)
12462
e4dbfe3019b1 Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents: 12433
diff changeset
1079 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1080 %! assert (regexp ("abc\nabc", '(?-m)c$'), 7);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1081 %! assert (regexp ("abc\nabc", 'c$',"lineanchors"), [3, 7]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1082 %! assert (regexp ("abc\nabc", '(?m)c$'), [3,7]);
5779
12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman]
dbateman
parents: 5775
diff changeset
1083
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1084 %!assert (regexp ("this word", 's w'), 4)
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1085 %!assert (regexp ("this word", 's w', 'literalspacing'), 4)
12462
e4dbfe3019b1 Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents: 12433
diff changeset
1086 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1087 %! assert (regexp ("this word", '(?-x)s w', 'literalspacing'), 4);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1088 %! assert (regexp ("this word", 's w', 'freespacing'), zeros (1,0));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1089 %! assert (regexp ("this word", '(?x)s w'), zeros (1,0));
5779
12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman]
dbateman
parents: 5775
diff changeset
1090
14536
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1091 %!test
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1092 %! [s, e, te, m, t, nm, sp] = regexp ('OCTAVE', '[VOCT]*', 'noemptymatch');
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1093 %! assert (s, [1 5]);
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1094 %! assert (e, [3 5]);
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1095 %! assert (te, { zeros(0,2), zeros(0,2) });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1096 %! assert (m, { "OCT", "V" });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1097 %! assert (t, { cell(1,0), cell(1,0) });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1098 %! assert (isempty (fieldnames (nm)));
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1099 %! assert (sp, { "", "A", "E" });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1100
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1101 %!test
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1102 %! [s, e, te, m, t, nm, sp] = regexp ('OCTAVE', '([VOCT]*)', 'noemptymatch');
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1103 %! assert (s, [1 5]);
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1104 %! assert (e, [3 5]);
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1105 %! assert (te, { [1 3], [5 5] });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1106 %! assert (m, { "OCT", "V" });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1107 %! assert (t, { {"OCT"}, {"V"} });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1108 %! assert (isempty (fieldnames (nm)));
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1109 %! assert (sp, { "", "A", "E" });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1110
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1111 %!test
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1112 %! [s, e, te, m, t, nm, sp] = regexp ('OCTAVE', '[VOCT]*', 'emptymatch');
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1113 %! assert (s, [1 4 5 6 7]);
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1114 %! assert (e, [3 3 5 5 6]);
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1115 %! assert (te, repmat ({zeros(0,2)}, [1, 5]));
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1116 %! assert (m, { "OCT", "", "V", "", "" });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1117 %! assert (t, repmat({cell(1,0)}, [1, 5]));
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1118 %! assert (isempty (fieldnames (nm)));
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1119 %! assert (sp, { "", "", "A", "", "E", "" });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1120
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1121 %!test
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1122 %! [s, e, te, m, t, nm, sp] = regexp ('OCTAVE', '([VOCT]*)', 'emptymatch');
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1123 %! assert (s, [1 4 5 6 7]);
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1124 %! assert (e, [3 3 5 5 6]);
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1125 %! assert (te, { [1 3], [4 3], [5 5], [6 5], [7 6] });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1126 %! assert (m, { "OCT", "", "V", "", "" });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1127 %! assert (t, { {"OCT"}, {""}, {"V"}, {""}, {""} });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1128 %! assert (isempty (fieldnames (nm)));
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1129 %! assert (sp, { "", "", "A", "", "E", "" });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1130
30351
91c6288781ba maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
Rik <rik@octave.org>
parents: 29966
diff changeset
1131 %!assert (regexp ({'asdfg-dfd';'-dfd-dfd-';'qasfdfdaq'}, '-'),
91c6288781ba maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
Rik <rik@octave.org>
parents: 29966
diff changeset
1132 %! {6;[1,5,9];zeros(1,0)})
91c6288781ba maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
Rik <rik@octave.org>
parents: 29966
diff changeset
1133 %!assert (regexp ({'asdfg-dfd';'-dfd-dfd-';'qasfdfdaq'}, {'-';'f';'q'}),
91c6288781ba maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
Rik <rik@octave.org>
parents: 29966
diff changeset
1134 %! {6;[3,7];[1,9]})
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1135 %!assert (regexp ('Strings', {'t','s'}), {2, 7})
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1136
8093
dcc31f473596 Treat PCRE lookbehind operators in a manner that is approximately correct
David Bateman <dbateman@free.fr>
parents: 8021
diff changeset
1137 ## Test case for lookaround operators
12462
e4dbfe3019b1 Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents: 12433
diff changeset
1138 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1139 %! assert (regexp ('Iraq', 'q(?!u)'), 4);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1140 %! assert (regexp ('quit', 'q(?!u)'), zeros (1, 0));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1141 %! assert (regexp ('quit', 'q(?=u)' , 'match'), {'q'});
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1142 %! assert (regexp ("quit", 'q(?=u+)', 'match'), {'q'});
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1143 %! assert (regexp ("qit", 'q(?=u+)', 'match'), cell (1, 0));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1144 %! assert (regexp ("qit", 'q(?=u*)', 'match'), {'q'});
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1145 %! assert (regexp ('thingamabob', '(?<=a)b'), 9);
8093
dcc31f473596 Treat PCRE lookbehind operators in a manner that is approximately correct
David Bateman <dbateman@free.fr>
parents: 8021
diff changeset
1146
13310
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1147 ## Tests for split option.
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1148 %!shared str
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1149 %! str = "foo bar foo";
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1150 %!test
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1151 %! [a, b] = regexp (str, "f..", "match", "split");
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1152 %! assert (a, {"foo", "foo"});
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1153 %! assert (b, {"", " bar ", ""});
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1154 %!test
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1155 %! [a, b] = regexp (str, "f..", "match", "split", "once");
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1156 %! assert (a, "foo");
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1157 %! assert (b, {"", " bar foo"});
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1158 %!test
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1159 %! [a, b] = regexp (str, "fx.", "match", "split");
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1160 %! assert (a, cell (1, 0));
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1161 %! assert (b, {"foo bar foo"});
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1162 %!test
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1163 %! [a, b] = regexp (str, "fx.", "match", "split", "once");
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1164 %! assert (a, "");;
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1165 %! assert (b, "foo bar foo");
13310
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1166
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1167 %!shared str
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1168 %! str = "foo bar";
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1169 %!test
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1170 %! [a, b] = regexp (str, "f..", "match", "split");
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1171 %! assert (a, {"foo"});
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1172 %! assert (b, {"", " bar"});
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1173 %!test
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1174 %! [a, b] = regexp (str, "b..", "match", "split");
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1175 %! assert (a, {"bar"});
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1176 %! assert (b, {"foo ", ""});
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1177 %!test
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1178 %! [a, b] = regexp (str, "x", "match", "split");
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1179 %! assert (a, cell (1, 0));
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1180 %! assert (b, {"foo bar"});
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1181 %!test
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1182 %! [a, b] = regexp (str, "[o]+", "match", "split");
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1183 %! assert (a, {"oo"});
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1184 %! assert (b, {"f", " bar"});
14543
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
1185
24751
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1186 ## Test escape sequences are expanded even in single-quoted strings
21317
a4faec57f4c8 maint: remove semicolon after %!assert tests to follow Octave conventions.
Rik <rik@octave.org>
parents: 21301
diff changeset
1187 %!assert (regexp ("\n", '\n'), 1)
a4faec57f4c8 maint: remove semicolon after %!assert tests to follow Octave conventions.
Rik <rik@octave.org>
parents: 21301
diff changeset
1188 %!assert (regexp ("\n", "\n"), 1)
20290
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
1189
29350
8f0d0d4690c0 Change regexp start-of-word/end-of-word behavior for Matlab compatiblity (bug #59992).
Rik <rik@octave.org>
parents: 29122
diff changeset
1190 ## Test escape sequences are silently converted
23573
1b4f4ec53b4a use new script to tag fixed bugs in tests
John W. Eaton <jwe@octave.org>
parents: 23572
diff changeset
1191 %!test <*45407>
20290
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
1192 %! assert (regexprep ('s', 's', 'x\.y'), 'x.y');
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
1193 %! assert (regexprep ('s', '(s)', 'x\$1y'), 'x$1y');
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
1194 %! assert (regexprep ('s', '(s)', 'x\\$1y'), 'x\sy');
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407).
Rik <rik@octave.org>
parents: 20232
diff changeset
1195
29350
8f0d0d4690c0 Change regexp start-of-word/end-of-word behavior for Matlab compatiblity (bug #59992).
Rik <rik@octave.org>
parents: 29122
diff changeset
1196 ## Test start-of-word / end-of-word patterns for Matlab compatibility
8f0d0d4690c0 Change regexp start-of-word/end-of-word behavior for Matlab compatiblity (bug #59992).
Rik <rik@octave.org>
parents: 29122
diff changeset
1197 %!test <*59992>
8f0d0d4690c0 Change regexp start-of-word/end-of-word behavior for Matlab compatiblity (bug #59992).
Rik <rik@octave.org>
parents: 29122
diff changeset
1198 %! assert (regexp ('foo!+bar', '\<\w'), [1, 6]);
8f0d0d4690c0 Change regexp start-of-word/end-of-word behavior for Matlab compatiblity (bug #59992).
Rik <rik@octave.org>
parents: 29122
diff changeset
1199 %! assert (regexp ('foo!+bar', '.\>'), [3, 4, 8]);
8f0d0d4690c0 Change regexp start-of-word/end-of-word behavior for Matlab compatiblity (bug #59992).
Rik <rik@octave.org>
parents: 29122
diff changeset
1200 %! assert (regexp ('foo!+bar\nbar!+foo', '.\>'), [3, 4, 8, 13, 14, 18]);
8f0d0d4690c0 Change regexp start-of-word/end-of-word behavior for Matlab compatiblity (bug #59992).
Rik <rik@octave.org>
parents: 29122
diff changeset
1201 %! assert (regexp ('foo!+bar\nbar!+foo', '\<\w'), [1, 6, 10, 16]);
8f0d0d4690c0 Change regexp start-of-word/end-of-word behavior for Matlab compatiblity (bug #59992).
Rik <rik@octave.org>
parents: 29122
diff changeset
1202
24751
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1203 ## Test input validation
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1204 %!error regexp ('string', 'tri', 'BadArg')
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1205 %!error regexp ('string')
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1206
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1207 */
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1208
15039
e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents: 14854
diff changeset
1209 DEFUN (regexpi, args, nargout,
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1210 doc: /* -*- texinfo -*-
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1211 @deftypefn {} {[@var{s}, @var{e}, @var{te}, @var{m}, @var{t}, @var{nm}, @var{sp}] =} regexpi (@var{str}, @var{pat})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1212 @deftypefnx {} {[@dots{}] =} regexpi (@var{str}, @var{pat}, "@var{opt1}", @dots{})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1213
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1214 Case insensitive regular expression string matching.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1215
27542
7dc31256c5e4 Document that regexp* functions need UTF-8 encoded input (bug #35910).
Markus Mützel <markus.muetzel@gmx.de>
parents: 27282
diff changeset
1216 Search for @var{pat} in UTF-8 encoded @var{str} and return the positions and
7dc31256c5e4 Document that regexp* functions need UTF-8 encoded input (bug #35910).
Markus Mützel <markus.muetzel@gmx.de>
parents: 27282
diff changeset
1217 substrings of any matches, or empty values if there are none.
28966
d9d028b479ac doc: Use @code{} within alternate text for @xref,@pxref macros in libinterp/
Rik <rik@octave.org>
parents: 27928
diff changeset
1218 @xref{XREFregexp,,@code{regexp}}, for details on the syntax of the search
d9d028b479ac doc: Use @code{} within alternate text for @xref,@pxref macros in libinterp/
Rik <rik@octave.org>
parents: 27928
diff changeset
1219 pattern.
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1220 @seealso{regexp}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1221 @end deftypefn */)
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1222 {
20821
b169da150702 Eliminate unnecessary uses of nargin.
Rik <rik@octave.org>
parents: 20819
diff changeset
1223 if (args.length () < 2)
b169da150702 Eliminate unnecessary uses of nargin.
Rik <rik@octave.org>
parents: 20819
diff changeset
1224 print_usage ();
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1225
23576
00e518162fda maint: Deprecate is_cell and replace with iscell.
Rik <rik@octave.org>
parents: 23573
diff changeset
1226 if (args(0).iscell () || args(1).iscell ())
20939
b17fda023ca6 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20853
diff changeset
1227 return octcellregexp (args, (nargout > 0 ? nargout : 1), "regexpi", true);
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1228 else
20939
b17fda023ca6 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20853
diff changeset
1229 return octregexp (args, nargout, "regexpi", true);
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1230 }
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1231
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1232 /*
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1233 ## segfault test
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1234 %!assert (regexpi ("abcde", "."), [1,2,3,4,5])
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1235
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1236 ## Check that anchoring of pattern works correctly
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1237 %!assert (regexpi ('abcabc', '^ABC'), 1)
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1238 %!assert (regexpi ('abcabc', 'ABC$'), 4)
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1239 %!assert (regexpi ('abcabc', '^ABC$'), zeros (1,0))
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1240
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1241 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1242 %! [s, e, te, m, t] = regexpi (' No Match ', 'f(.*)uck');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1243 %! assert (s, zeros (1,0));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1244 %! assert (e, zeros (1,0));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1245 %! assert (te, cell (1,0));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1246 %! assert (m, cell (1,0));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1247 %! assert (t, cell (1,0));
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1248
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1249 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1250 %! [s, e, te, m, t] = regexpi (' FiRetrUck ', 'f(.*)uck');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1251 %! assert (s, 2);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1252 %! assert (e, 10);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1253 %! assert (te{1}, [3, 7]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1254 %! assert (m{1}, 'FiRetrUck');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1255 %! assert (t{1}{1}, 'iRetr');
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1256
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1257 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1258 %! [s, e, te, m, t] = regexpi (' firetruck ', 'f(.*)uck');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1259 %! assert (s, 2);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1260 %! assert (e, 10);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1261 %! assert (te{1}, [3, 7]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1262 %! assert (m{1}, 'firetruck');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1263 %! assert (t{1}{1}, 'iretr');
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1264
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1265 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1266 %! [s, e, te, m, t] = regexpi ('ShoRt Test String', '\w*r\w*');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1267 %! assert (s, [1, 12]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1268 %! assert (e, [5, 17]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1269 %! assert (size (te), [1, 2]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1270 %! assert (isempty (te{1}));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1271 %! assert (isempty (te{2}));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1272 %! assert (m{1}, 'ShoRt');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1273 %! assert (m{2}, 'String');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1274 %! assert (size (t), [1, 2]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1275 %! assert (isempty (t{1}));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1276 %! assert (isempty (t{2}));
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1277
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1278 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1279 %! [s, e, te, m, t] = regexpi ('ShoRt Test String', '\w*r\w*', 'once');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1280 %! assert (s, 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1281 %! assert (e, 5);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1282 %! assert (isempty (te));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1283 %! assert (m, 'ShoRt');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1284 %! assert (isempty (t));
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1285
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1286 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1287 %! [m, te, e, s, t] = regexpi ('ShoRt Test String', '\w*r\w*', 'once', 'match', 'tokenExtents', 'end', 'start', 'tokens');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1288 %! assert (s, 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1289 %! assert (e, 5);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1290 %! assert (isempty (te));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1291 %! assert (m, 'ShoRt');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1292 %! assert (isempty (t));
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1293
12462
e4dbfe3019b1 Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents: 12433
diff changeset
1294 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1295 %! [s, e, te, m, t, nm] = regexpi ('ShoRt Test String', '(?<word1>\w*t)\s*(?<word2>\w*t)');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1296 %! assert (s, 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1297 %! assert (e, 10);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1298 %! assert (size (te), [1, 1]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1299 %! assert (te{1}, [1,5; 7,10]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1300 %! assert (m{1}, 'ShoRt Test');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1301 %! assert (size (t), [1, 1]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1302 %! assert (t{1}{1}, 'ShoRt');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1303 %! assert (t{1}{2}, 'Test');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1304 %! assert (size (nm), [1, 1]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1305 %! assert (! isempty (fieldnames (nm)));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1306 %! assert (sort (fieldnames (nm)), {'word1';'word2'});
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1307 %! assert (nm.word1, 'ShoRt');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1308 %! assert (nm.word2, 'Test');
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1309
12462
e4dbfe3019b1 Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents: 12433
diff changeset
1310 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1311 %! [nm, m, te, e, s, t] = regexpi ('ShoRt Test String', '(?<word1>\w*t)\s*(?<word2>\w*t)', 'names', 'match', 'tokenExtents', 'end', 'start', 'tokens');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1312 %! assert (s, 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1313 %! assert (e, 10);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1314 %! assert (size (te), [1, 1]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1315 %! assert (te{1}, [1,5; 7,10]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1316 %! assert (m{1}, 'ShoRt Test');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1317 %! assert (size (t), [1, 1]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1318 %! assert (t{1}{1}, 'ShoRt');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1319 %! assert (t{1}{2}, 'Test');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1320 %! assert (size (nm), [1, 1]);
20955
77f5591878bf maint: Use '! expr' rather than '!expr' to conform to coding guidelines.
Rik <rik@octave.org>
parents: 20940
diff changeset
1321 %! assert (! isempty (fieldnames (nm)));
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1322 %! assert (sort (fieldnames (nm)), {'word1';'word2'});
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1323 %! assert (nm.word1, 'ShoRt');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1324 %! assert (nm.word2, 'Test');
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1325
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1326 %!assert (regexpi ("abc\nabc", '.'), [1:7])
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1327 %!assert (regexpi ("abc\nabc", '.', 'dotall'), [1:7])
12462
e4dbfe3019b1 Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents: 12433
diff changeset
1328 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1329 %! assert (regexpi ("abc\nabc", '(?s).'), [1:7]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1330 %! assert (regexpi ("abc\nabc", '.', 'dotexceptnewline'), [1,2,3,5,6,7]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1331 %! assert (regexpi ("abc\nabc", '(?-s).'), [1,2,3,5,6,7]);
5779
12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman]
dbateman
parents: 5775
diff changeset
1332
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1333 %!assert (regexpi ("caseCaSe", 'case'), [1, 5])
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1334 %!assert (regexpi ("caseCaSe", 'case', "matchcase"), 1)
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1335 %!assert (regexpi ("caseCaSe", 'case', "ignorecase"), [1, 5])
12462
e4dbfe3019b1 Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents: 12433
diff changeset
1336 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1337 %! assert (regexpi ("caseCaSe", '(?-i)case'), 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1338 %! assert (regexpi ("caseCaSe", '(?i)case'), [1, 5]);
5779
12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman]
dbateman
parents: 5775
diff changeset
1339
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1340 %!assert (regexpi ("abc\nabc", 'C$'), 7)
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1341 %!assert (regexpi ("abc\nabc", 'C$', "stringanchors"), 7)
12462
e4dbfe3019b1 Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents: 12433
diff changeset
1342 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1343 %! assert (regexpi ("abc\nabc", '(?-m)C$'), 7);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1344 %! assert (regexpi ("abc\nabc", 'C$', "lineanchors"), [3, 7]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1345 %! assert (regexpi ("abc\nabc", '(?m)C$'), [3, 7]);
5779
12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman]
dbateman
parents: 5775
diff changeset
1346
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1347 %!assert (regexpi ("this word", 'S w'), 4)
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1348 %!assert (regexpi ("this word", 'S w', 'literalspacing'), 4)
12462
e4dbfe3019b1 Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents: 12433
diff changeset
1349 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1350 %! assert (regexpi ("this word", '(?-x)S w', 'literalspacing'), 4);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1351 %! assert (regexpi ("this word", 'S w', 'freespacing'), zeros (1,0));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1352 %! assert (regexpi ("this word", '(?x)S w'), zeros (1,0));
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1353
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1354 %!error regexpi ('string', 'tri', 'BadArg')
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1355 %!error regexpi ('string')
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1356
30351
91c6288781ba maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
Rik <rik@octave.org>
parents: 29966
diff changeset
1357 %!assert (regexpi ({'asdfg-dfd';'-dfd-dfd-';'qasfdfdaq'}, '-'),
91c6288781ba maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
Rik <rik@octave.org>
parents: 29966
diff changeset
1358 %! {6;[1,5,9];zeros(1, 0)})
91c6288781ba maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
Rik <rik@octave.org>
parents: 29966
diff changeset
1359 %!assert (regexpi ({'asdfg-dfd', '-dfd-dfd-', 'qasfdfdaq'}, '-'),
91c6288781ba maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
Rik <rik@octave.org>
parents: 29966
diff changeset
1360 %! {6, [1,5,9], zeros(1,0)})
91c6288781ba maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
Rik <rik@octave.org>
parents: 29966
diff changeset
1361 %!assert (regexpi ({'asdfg-dfd';'-dfd-dfd-';'qasfdfdaq'}, {'-';'f';'q'}),
91c6288781ba maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
Rik <rik@octave.org>
parents: 29966
diff changeset
1362 %! {6;[3,7];[1,9]})
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1363 %!assert (regexpi ('Strings', {'t', 's'}), {2, [1, 7]})
14543
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
1364
21317
a4faec57f4c8 maint: remove semicolon after %!assert tests to follow Octave conventions.
Rik <rik@octave.org>
parents: 21301
diff changeset
1365 %!assert (regexpi ("\n", '\n'), 1)
a4faec57f4c8 maint: remove semicolon after %!assert tests to follow Octave conventions.
Rik <rik@octave.org>
parents: 21301
diff changeset
1366 %!assert (regexpi ("\n", "\n"), 1)
5582
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1367 */
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe]
jwe
parents:
diff changeset
1368
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1369 static octave_value
23433
c9fab0bc983e maint: Use convention 'int& x' for naming references.
Rik <rik@octave.org>
parents: 23220
diff changeset
1370 octregexprep (const octave_value_list& args, const std::string& who)
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1371 {
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1372 int nargin = args.length ();
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1373
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1374 // Make sure we have string, pattern, replacement
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1375 const std::string buffer = args(0).string_value ();
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1376
14543
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
1377 std::string pattern = args(1).string_value ();
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1378
22722
e6fac42c8d56 Fix regexp handling of beginning/end word match for double-quoted pattern strings (bug #49451).
Rik <rik@octave.org>
parents: 22599
diff changeset
1379 // Rewrite pattern for PCRE
e6fac42c8d56 Fix regexp handling of beginning/end word match for double-quoted pattern strings (bug #49451).
Rik <rik@octave.org>
parents: 22599
diff changeset
1380 pattern = do_regexp_ptn_string_escapes (pattern, args(1).is_sq_string ());
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1381
14543
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
1382 std::string replacement = args(2).string_value ();
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1383
14543
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
1384 // Matlab compatibility.
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
1385 if (args(2).is_sq_string ())
15541
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents: 15195
diff changeset
1386 replacement = do_regexp_rep_string_escapes (replacement);
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11572
diff changeset
1387
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1388 // Pack options excluding 'tokenize' and various output
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1389 // reordering strings into regexp arg list
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
1390 octave_value_list regexpargs (nargin-3, octave_value ());
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1391
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
1392 int len = 0;
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11572
diff changeset
1393 for (int i = 3; i < nargin; i++)
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1394 {
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1395 const std::string opt = args(i).string_value ();
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1396 if (opt != "tokenize" && opt != "start" && opt != "end"
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
1397 && opt != "tokenextents" && opt != "match" && opt != "tokens"
13310
583940a28bfd handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents: 13227
diff changeset
1398 && opt != "names" && opt != "split" && opt != "warnings")
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
1399 {
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
1400 regexpargs(len++) = args(i);
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
1401 }
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1402 }
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1403 regexpargs.resize (len);
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11572
diff changeset
1404
29966
7d6709900da7 eliminate octave:: namespace tags in DEFUN and DEFMETHOD and more
John W. Eaton <jwe@octave.org>
parents: 29963
diff changeset
1405 regexp::opts options;
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
1406 bool extra_args = false;
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
1407 parse_options (options, regexpargs, who, 0, extra_args);
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1408
29966
7d6709900da7 eliminate octave:: namespace tags in DEFUN and DEFMETHOD and more
John W. Eaton <jwe@octave.org>
parents: 29963
diff changeset
1409 return regexp::replace (pattern, buffer, replacement, options, who);
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1410 }
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1411
15039
e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents: 14854
diff changeset
1412 DEFUN (regexprep, args, ,
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1413 doc: /* -*- texinfo -*-
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1414 @deftypefn {} {@var{outstr} =} regexprep (@var{string}, @var{pat}, @var{repstr})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1415 @deftypefnx {} {@var{outstr} =} regexprep (@var{string}, @var{pat}, @var{repstr}, "@var{opt1}", @dots{})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1416 Replace occurrences of pattern @var{pat} in @var{string} with @var{repstr}.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1417
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1418 The pattern is a regular expression as documented for @code{regexp}.
28966
d9d028b479ac doc: Use @code{} within alternate text for @xref,@pxref macros in libinterp/
Rik <rik@octave.org>
parents: 27928
diff changeset
1419 @xref{XREFregexp,,@code{regexp}}.
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1420
27542
7dc31256c5e4 Document that regexp* functions need UTF-8 encoded input (bug #35910).
Markus Mützel <markus.muetzel@gmx.de>
parents: 27282
diff changeset
1421 All strings must be UTF-8 encoded.
7dc31256c5e4 Document that regexp* functions need UTF-8 encoded input (bug #35910).
Markus Mützel <markus.muetzel@gmx.de>
parents: 27282
diff changeset
1422
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1423 The replacement string may contain @code{$i}, which substitutes for the ith
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1424 set of parentheses in the match string. For example,
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1425
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1426 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1427 regexprep ("Bill Dunn", '(\w+) (\w+)', '$2, $1')
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1428 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1429
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1430 @noindent
22299
9fc91bb2aec3 doc: grammarcheck documentation for 4.2 release.
Rik <rik@octave.org>
parents: 22197
diff changeset
1431 returns @qcode{"Dunn, Bill"}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1432
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1433 Options in addition to those of @code{regexp} are
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1434
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1435 @table @samp
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1436
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1437 @item once
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1438 Replace only the first occurrence of @var{pat} in the result.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1439
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1440 @item warnings
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1441 This option is present for compatibility but is ignored.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1442
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1443 @end table
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1444
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1445 Implementation Note: For compatibility with @sc{matlab}, escape sequences
29122
10a35049bad7 doc: Cleanup Texinfo macros use in documentation.
Rik <rik@octave.org>
parents: 28966
diff changeset
1446 in @var{pat} (e.g., @qcode{"@backslashchar{}n"} => newline) are expanded
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1447 even when @var{pat} has been defined with single quotes. To disable
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1448 expansion use a second backslash before the escape sequence (e.g.,
29122
10a35049bad7 doc: Cleanup Texinfo macros use in documentation.
Rik <rik@octave.org>
parents: 28966
diff changeset
1449 "@backslashchar{}@backslashchar{}n") or use the @code{regexptranslate}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1450 function.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1451 @seealso{regexp, regexpi, strrep}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1452 @end deftypefn */)
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1453 {
20821
b169da150702 Eliminate unnecessary uses of nargin.
Rik <rik@octave.org>
parents: 20819
diff changeset
1454 if (args.length () < 3)
b169da150702 Eliminate unnecessary uses of nargin.
Rik <rik@octave.org>
parents: 20819
diff changeset
1455 print_usage ();
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1456
20821
b169da150702 Eliminate unnecessary uses of nargin.
Rik <rik@octave.org>
parents: 20819
diff changeset
1457 octave_value_list retval;
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1458
23576
00e518162fda maint: Deprecate is_cell and replace with iscell.
Rik <rik@octave.org>
parents: 23573
diff changeset
1459 if (args(0).iscell () || args(1).iscell () || args(2).iscell ())
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1460 {
20821
b169da150702 Eliminate unnecessary uses of nargin.
Rik <rik@octave.org>
parents: 20819
diff changeset
1461 Cell str, pat, rep;
6495
fd09c7e8c4c9 [project @ 2007-04-05 16:18:20 by dbateman]
dbateman
parents: 6361
diff changeset
1462 dim_vector dv0;
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1463 dim_vector dv1 (1, 1);
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1464
23576
00e518162fda maint: Deprecate is_cell and replace with iscell.
Rik <rik@octave.org>
parents: 23573
diff changeset
1465 if (args(0).iscell ())
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1466 str = args(0).cell_value ();
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1467 else
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
1468 str = Cell (args(0));
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1469
23576
00e518162fda maint: Deprecate is_cell and replace with iscell.
Rik <rik@octave.org>
parents: 23573
diff changeset
1470 if (args(1).iscell ())
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1471 pat = args(1).cell_value ();
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1472 else
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
1473 pat = Cell (args(1));
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1474
23576
00e518162fda maint: Deprecate is_cell and replace with iscell.
Rik <rik@octave.org>
parents: 23573
diff changeset
1475 if (args(2).iscell ())
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1476 rep = args(2).cell_value ();
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1477 else
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
1478 rep = Cell (args(2));
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1479
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1480 dv0 = str.dims ();
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1481 if (pat.numel () != 1)
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
1482 {
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1483 dv1 = pat.dims ();
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1484 if (rep.numel () != 1 && dv1 != rep.dims ())
14024
fc9f204faea0 refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents: 13929
diff changeset
1485 error ("regexprep: inconsistent cell array dimensions");
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
1486 }
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1487 else if (rep.numel () != 1)
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1488 dv1 = rep.dims ();
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1489
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1490 Cell ret (dv0);
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1491 octave_value_list new_args = args;
13227
9559417aa965 maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents: 12642
diff changeset
1492
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1493 for (octave_idx_type i = 0; i < dv0.numel (); i++)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1494 {
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1495 new_args(0) = str(i);
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1496 if (pat.numel () == 1)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1497 new_args(1) = pat(0);
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1498 if (rep.numel () == 1)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1499 new_args(2) = rep(0);
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1500
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1501 for (octave_idx_type j = 0; j < dv1.numel (); j++)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1502 {
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1503 if (pat.numel () != 1)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1504 new_args(1) = pat(j);
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1505 if (rep.numel () != 1)
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1506 new_args(2) = rep(j);
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1507 new_args(0) = octregexprep (new_args, "regexprep");
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
1508 }
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1509
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1510 ret(i) = new_args(0);
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 9064
diff changeset
1511 }
20558
1a0a433c8263 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20290
diff changeset
1512
23576
00e518162fda maint: Deprecate is_cell and replace with iscell.
Rik <rik@octave.org>
parents: 23573
diff changeset
1513 retval = (args(0).iscell () ? ovl (ret) : ovl (ret(0)));
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1514 }
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1515 else
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1516 retval = octregexprep (args, "regexprep");
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1517
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1518 return retval;
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1519 }
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1520
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1521 /*
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1522 %!test # Replace with empty
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1523 %! xml = '<!-- This is some XML --> <tag v="hello">some stuff<!-- sample tag--></tag>';
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1524 %! t = regexprep (xml, '<[!?][^>]*>', '');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1525 %! assert (t, ' <tag v="hello">some stuff</tag>');
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1526
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1527 %!test # Replace with non-empty
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1528 %! xml = '<!-- This is some XML --> <tag v="hello">some stuff<!-- sample tag--></tag>';
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1529 %! t = regexprep (xml, '<[!?][^>]*>', '?');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1530 %! assert (t, '? <tag v="hello">some stuff?</tag>');
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1531
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1532 %!test # Check that 'tokenize' is ignored
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1533 %! xml = '<!-- This is some XML --> <tag v="hello">some stuff<!-- sample tag--></tag>';
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1534 %! t = regexprep (xml, '<[!?][^>]*>', '', 'tokenize');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1535 %! assert (t, ' <tag v="hello">some stuff</tag>');
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1536
11032
c9b0a75b02e8 Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents: 11025
diff changeset
1537 ## Test capture replacement
12462
e4dbfe3019b1 Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents: 12433
diff changeset
1538 %!test
7242
e4398e3903be [project @ 2007-12-03 23:52:07 by dbateman]
dbateman
parents: 7237
diff changeset
1539 %! data = "Bob Smith\nDavid Hollerith\nSam Jenkins";
e4398e3903be [project @ 2007-12-03 23:52:07 by dbateman]
dbateman
parents: 7237
diff changeset
1540 %! result = "Smith, Bob\nHollerith, David\nJenkins, Sam";
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1541 %! t = regexprep (data, '(?m)^(\w+)\s+(\w+)$', '$2, $1');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1542 %! assert (t, result);
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1543
11032
c9b0a75b02e8 Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents: 11025
diff changeset
1544 ## Return the original if no match
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1545 %!assert (regexprep ('hello', 'world', 'earth'), 'hello')
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1546
24751
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1547 ## Test emptymatch option
14536
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1548 %!assert (regexprep ('World', '^', 'Hello '), 'World')
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1549 %!assert (regexprep ('World', '^', 'Hello ', 'emptymatch'), 'Hello World')
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents: 14501
diff changeset
1550
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1551 ## Test a general replacement
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1552 %!assert (regexprep ("a[b]c{d}e-f=g", "[^A-Za-z0-9_]", "_"), "a_b_c_d_e_f_g")
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1553
24751
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1554 ## Make sure replacements work at the beginning and end of string
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1555 %!assert (regexprep ("a[b]c{d}e-f=g", "a", "_"), "_[b]c{d}e-f=g")
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1556 %!assert (regexprep ("a[b]c{d}e-f=g", "g", "_"), "a[b]c{d}e-f=_")
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1557
24751
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1558 ## Test options "once" and "ignorecase"
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1559 %!assert (regexprep ("a[b]c{d}e-f=g", "[^A-Za-z0-9_]", "_", "once"),
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1560 %! "a_b]c{d}e-f=g")
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1561 %!assert (regexprep ("a[b]c{d}e-f=g", "[^A-Z0-9_]", "_", "ignorecase"),
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1562 %! "a_b_c_d_e_f_g")
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1563
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1564 ## Option combinations
24751
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1565 %!assert (regexprep ("a[b]c{d}e-f=g", "[^A-Z0-9_]", "_", "once", "ignorecase"),
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1566 %! "a_b]c{d}e-f=g")
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1567
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1568 ## End conditions on replacement
21317
a4faec57f4c8 maint: remove semicolon after %!assert tests to follow Octave conventions.
Rik <rik@octave.org>
parents: 21301
diff changeset
1569 %!assert (regexprep ("abc", "(b)", ".$1"), "a.bc")
a4faec57f4c8 maint: remove semicolon after %!assert tests to follow Octave conventions.
Rik <rik@octave.org>
parents: 21301
diff changeset
1570 %!assert (regexprep ("abc", "(b)", "$1"), "abc")
a4faec57f4c8 maint: remove semicolon after %!assert tests to follow Octave conventions.
Rik <rik@octave.org>
parents: 21301
diff changeset
1571 %!assert (regexprep ("abc", "(b)", "$1."), "ab.c")
a4faec57f4c8 maint: remove semicolon after %!assert tests to follow Octave conventions.
Rik <rik@octave.org>
parents: 21301
diff changeset
1572 %!assert (regexprep ("abc", "(b)", "$1.."), "ab..c")
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1573
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1574 ## Test cell array arguments
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1575 %!assert (regexprep ("abc", {"b","a"}, "?"), "??c")
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1576 %!assert (regexprep ({"abc","cba"}, "b", "?"), {"a?c","c?a"})
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14496
diff changeset
1577 %!assert (regexprep ({"abc","cba"}, {"b","a"}, {"?","!"}), {"!?c","c?!"})
6361
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman]
dbateman
parents: 5866
diff changeset
1578
24751
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1579 ## Nasty lookbehind expression
21575
bc9aa534bc29 maint: Clean up BIST tests so they don't produce warnings.
Rik <rik@octave.org>
parents: 21547
diff changeset
1580 %!test
bc9aa534bc29 maint: Clean up BIST tests so they don't produce warnings.
Rik <rik@octave.org>
parents: 21547
diff changeset
1581 %! warning ("off", "Octave:regexp-lookbehind-limit", "local");
24751
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1582 %! assert (regexprep ('x^(-1)+y(-1)+z(-1)=0', '(?<=[a-z]+)\(\-[1-9]*\)',
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1583 %! '_minus1'),'x^(-1)+y_minus1+z_minus1=0');
14543
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents: 14536
diff changeset
1584
24751
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1585 ## Verify escape sequences in pattern
21317
a4faec57f4c8 maint: remove semicolon after %!assert tests to follow Octave conventions.
Rik <rik@octave.org>
parents: 21301
diff changeset
1586 %!assert (regexprep ("\n", '\n', "X"), "X")
a4faec57f4c8 maint: remove semicolon after %!assert tests to follow Octave conventions.
Rik <rik@octave.org>
parents: 21301
diff changeset
1587 %!assert (regexprep ("\n", "\n", "X"), "X")
24606
4a4a8b2a5bf2 Test for incorrect regexprep on ARM platforms (bug #52810).
Colin Macdonald <cbm@m.fsf.org>
parents: 23816
diff changeset
1588
24751
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1589 ## Verify NULLs in pattern and replacement string
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1590 %!assert (regexprep ("A\0A", "\0", ","), "A,A")
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1591 %!assert (regexprep ("A\0A", '\0', ","), "A,A")
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1592 %!assert (regexprep ("A,A", "A", "B\0B"), "B\0B,B\0B")
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1593 %!assert (regexprep ("A,A", "A", 'B\0B'), "B\0B,B\0B")
6e670c58c6f0 Expand octal sequences in regexprep replacement string for Matlab compatibility.
Rik <rik@octave.org>
parents: 24741
diff changeset
1594
24606
4a4a8b2a5bf2 Test for incorrect regexprep on ARM platforms (bug #52810).
Colin Macdonald <cbm@m.fsf.org>
parents: 23816
diff changeset
1595 ## Empty matches were broken on ARM architecture
4a4a8b2a5bf2 Test for incorrect regexprep on ARM platforms (bug #52810).
Colin Macdonald <cbm@m.fsf.org>
parents: 23816
diff changeset
1596 %!test <*52810>
30351
91c6288781ba maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
Rik <rik@octave.org>
parents: 29966
diff changeset
1597 %! assert (strcmp (regexprep ("\nabc", "^(\t*)(abc)$", "$1$2", "lineanchors"),
91c6288781ba maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
Rik <rik@octave.org>
parents: 29966
diff changeset
1598 %! "\nabc"));
5785
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman]
dbateman
parents: 5779
diff changeset
1599 */
29963
32c3a5805893 move DEFUN and DEFMETHOD functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29660
diff changeset
1600
32c3a5805893 move DEFUN and DEFMETHOD functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29660
diff changeset
1601 OCTAVE_NAMESPACE_END