Mercurial > jwe > octave
annotate src/DLD-FUNCTIONS/regexp.cc @ 14496:bd592d5482c0
doc: Add SP to list of outputs in docstring for regexp, regexpi.
regexp.cc (regexp, regexpi): Add SP to list of outputs in docstring.
author | Rik <octave@nomad.inbox5.com> |
---|---|
date | Sun, 25 Mar 2012 14:18:51 -0700 |
parents | 2232931f2494 |
children | 60e5cf354d80 |
rev | line source |
---|---|
5582 | 1 /* |
2 | |
14138
72c96de7a403
maint: update copyright notices for 2012
John W. Eaton <jwe@octave.org>
parents:
14024
diff
changeset
|
3 Copyright (C) 2005-2012 David Bateman |
11523 | 4 Copyright (C) 2002-2005 Paul Kienzle |
7016 | 5 |
6 This file is part of Octave. | |
5582 | 7 |
8 Octave is free software; you can redistribute it and/or modify it | |
9 under the terms of the GNU General Public License as published by the | |
7016 | 10 Free Software Foundation; either version 3 of the License, or (at your |
11 option) any later version. | |
5582 | 12 |
13 Octave is distributed in the hope that it will be useful, but WITHOUT | |
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
16 for more details. | |
17 | |
18 You should have received a copy of the GNU General Public License | |
7016 | 19 along with Octave; see the file COPYING. If not, see |
20 <http://www.gnu.org/licenses/>. | |
5582 | 21 |
22 */ | |
23 | |
24 #ifdef HAVE_CONFIG_H | |
25 #include <config.h> | |
26 #endif | |
27 | |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
28 #include <list> |
5765 | 29 #include <sstream> |
30 | |
5582 | 31 #include <pcre.h> |
32 | |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
33 #include "base-list.h" |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
34 #include "oct-locbuf.h" |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
35 #include "quit.h" |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
36 #include "regexp.h" |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
37 #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
|
38 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
39 #include "defun-dld.h" |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
40 #include "Cell.h" |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
41 #include "error.h" |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
42 #include "gripes.h" |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
43 #include "oct-map.h" |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
44 #include "oct-obj.h" |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
45 #include "utils.h" |
5785 | 46 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
47 static void |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
48 parse_options (regexp::opts& options, const octave_value_list& args, |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
49 const std::string& who, int skip, bool& extra_args) |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
50 { |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
51 int nargin = args.length (); |
5582 | 52 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
53 extra_args = false; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
54 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
55 for (int i = skip; i < nargin; i++) |
5582 | 56 { |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
57 std::string str = args(i).string_value (); |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
58 |
5582 | 59 if (error_state) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
60 { |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
61 error ("%s: optional arguments must be character strings", |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
62 who.c_str ()); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
63 break; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
64 } |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
65 |
5582 | 66 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
|
67 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
68 if (str.find ("once", 0) == 0) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
69 options.once (true); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
70 else if (str.find ("matchcase", 0) == 0) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
71 options.case_insensitive (false); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
72 else if (str.find ("ignorecase", 0) == 0) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
73 options.case_insensitive (true); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
74 else if (str.find ("dotall", 0) == 0) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
75 options.dotexceptnewline (false); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
76 else if (str.find ("stringanchors", 0) == 0) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
77 options.lineanchors (false); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
78 else if (str.find ("literalspacing", 0) == 0) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
79 options.freespacing (false); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
80 else if (str.find ("dotexceptnewline", 0) == 0) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
81 options.dotexceptnewline (true); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
82 else if (str.find ("lineanchors", 0) == 0) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
83 options.lineanchors (true); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
84 else if (str.find ("freespacing", 0) == 0) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
85 options.freespacing (true); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
86 else if (str.find ("start", 0) == 0 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
87 || str.find ("end", 0) == 0 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
88 || str.find ("tokenextents", 0) == 0 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
89 || str.find ("match", 0) == 0 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
90 || str.find ("tokens", 0) == 0 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
91 || str.find ("names", 0) == 0 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
92 || str.find ("split", 0) == 0) |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
93 extra_args = true; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
94 else |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
95 error ("%s: unrecognized option", who.c_str ()); |
5582 | 96 } |
5785 | 97 } |
5582 | 98 |
5785 | 99 static octave_value_list |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
100 octregexp (const octave_value_list &args, int nargout, |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
101 const std::string &who, bool case_insensitive = false) |
5785 | 102 { |
103 octave_value_list retval; | |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
104 |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
105 int nargin = args.length (); |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
106 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
107 // Make sure we have string, pattern |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
108 const std::string buffer = args(0).string_value (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
109 if (error_state) |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
110 return retval; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
111 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
112 const std::string pattern = args(1).string_value (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
113 if (error_state) |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
114 return retval; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
115 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
116 regexp::opts options; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
117 options.case_insensitive (case_insensitive); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
118 bool extra_options = false; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
119 parse_options (options, args, who, 2, extra_options); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
120 if (error_state) |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
121 return retval; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
122 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
123 regexp::match_data rx_lst = regexp_match (pattern, buffer, options, who); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
124 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
125 string_vector named_pats = rx_lst.named_patterns (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
126 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
127 size_t sz = rx_lst.size (); |
5785 | 128 |
129 if (! error_state) | |
130 { | |
131 // Converted the linked list in the correct form for the return values | |
132 | |
133 octave_idx_type i = 0; | |
11045
cc3aad9dd3ef
dispatch.cc, fltk_backend.cc, regexp.cc: use octave_scalar_map instead of Octave_map
John W. Eaton <jwe@octave.org>
parents:
11032
diff
changeset
|
134 octave_scalar_map nmap; |
12464
dfeea9cae79e
require PCRE to build Octave
John W. Eaton <jwe@octave.org>
parents:
12462
diff
changeset
|
135 |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
136 retval.resize (7); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
137 |
5785 | 138 if (sz == 1) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
139 { |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
140 string_vector named_tokens = rx_lst.begin()->named_tokens (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
141 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
142 for (int j = 0; j < named_pats.length (); j++) |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
143 nmap.assign (named_pats(j), named_tokens(j)); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
144 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
145 retval(5) = nmap; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
146 } |
5785 | 147 else |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
148 { |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
149 for (int j = 0; j < named_pats.length (); j++) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
150 { |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
151 Cell tmp (dim_vector (1, sz)); |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
152 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
153 i = 0; |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
154 for (regexp::match_data::const_iterator p = rx_lst.begin (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
155 p != rx_lst.end (); p++) |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
156 { |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
157 string_vector named_tokens = p->named_tokens (); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
158 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
159 tmp(i++) = named_tokens(j); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
160 } |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
161 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
162 nmap.assign (named_pats(j), octave_value (tmp)); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
163 } |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
164 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
165 retval(5) = nmap; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
166 } |
5785 | 167 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
168 if (options.once ()) |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
169 { |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
170 regexp::match_data::const_iterator p = rx_lst.begin (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
171 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
172 retval(4) = sz ? p->tokens () : Cell (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
173 retval(3) = sz ? p->match_string () : std::string (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
174 retval(2) = sz ? p->token_extents () : Matrix (); |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
175 |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
176 if (sz) |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
177 { |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
178 double start = p->start (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
179 double end = p->end (); |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
180 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
181 Cell split (dim_vector (1, 2)); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
182 split(0) = buffer.substr (0, start-1); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
183 split(1) = buffer.substr (end); |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
184 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
185 retval(6) = split; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
186 retval(1) = end; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
187 retval(0) = start; |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
188 } |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
189 else |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
190 { |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
191 retval(6) = buffer; |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
192 retval(1) = Matrix (); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
193 retval(0) = Matrix (); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
194 } |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
195 } |
7893
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
196 else |
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
197 { |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
198 Cell tokens (dim_vector (1, sz)); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
199 Cell match_string (dim_vector (1, sz)); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
200 Cell token_extents (dim_vector (1, sz)); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
201 NDArray end (dim_vector (1, sz)); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
202 NDArray start (dim_vector (1, sz)); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
203 Cell split (dim_vector (1, sz+1)); |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
204 size_t sp_start = 0; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
205 |
7893
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
206 i = 0; |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
207 for (regexp::match_data::const_iterator p = rx_lst.begin (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
208 p != rx_lst.end (); p++) |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
209 { |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
210 double s = p->start (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
211 double e = p->end (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
212 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
213 string_vector tmp = p->tokens (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
214 tokens(i) = Cell (dim_vector (1, tmp.length ()), tmp); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
215 match_string(i) = p->match_string (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
216 token_extents(i) = p->token_extents (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
217 end(i) = e; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
218 start(i) = s; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
219 split(i) = buffer.substr (sp_start, s-sp_start-1); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
220 sp_start = e; |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
221 i++; |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
222 } |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
223 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
224 split(i) = buffer.substr (sp_start); |
5785 | 225 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
226 retval(6) = split; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
227 retval(4) = tokens; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
228 retval(3) = match_string; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
229 retval(2) = token_extents; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
230 retval(1) = end; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
231 retval(0) = start; |
7893
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
232 } |
5582 | 233 |
234 // Alter the order of the output arguments | |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
235 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
236 if (extra_options) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
237 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
238 int n = 0; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
239 octave_value_list new_retval; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
240 new_retval.resize (nargout); |
5582 | 241 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
242 OCTAVE_LOCAL_BUFFER (int, arg_used, 6); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
243 for (int j = 0; j < 6; j++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
244 arg_used[j] = false; |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11572
diff
changeset
|
245 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
246 for (int j = 2; j < nargin; j++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
247 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
248 int k = 0; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
249 std::string str = args(j).string_value (); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
250 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
|
251 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
252 if (str.find ("once", 0) == 0 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
253 || str.find ("stringanchors", 0) == 0 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
254 || str.find ("lineanchors", 0) == 0 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
255 || str.find ("matchcase", 0) == 0 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
256 || str.find ("ignorecase", 0) == 0 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
257 || str.find ("dotall", 0) == 0 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
258 || str.find ("dotexceptnewline", 0) == 0 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
259 || str.find ("literalspacing", 0) == 0 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
260 || str.find ("freespacing", 0) == 0) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
261 continue; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
262 else if (str.find ("start", 0) == 0) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
263 k = 0; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
264 else if (str.find ("end", 0) == 0) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
265 k = 1; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
266 else if (str.find ("tokenextents", 0) == 0) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
267 k = 2; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
268 else if (str.find ("match", 0) == 0) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
269 k = 3; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
270 else if (str.find ("tokens", 0) == 0) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
271 k = 4; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
272 else if (str.find ("names", 0) == 0) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
273 k = 5; |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
274 else if (str.find ("split", 0) == 0) |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
275 k = 6; |
5582 | 276 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
277 new_retval(n++) = retval(k); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
278 arg_used[k] = true; |
5582 | 279 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
280 if (n == nargout) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
281 break; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
282 } |
5582 | 283 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
284 // Fill in the rest of the arguments |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
285 if (n < nargout) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
286 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
287 for (int j = 0; j < 6; j++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
288 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
289 if (! arg_used[j]) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
290 new_retval(n++) = retval(j); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
291 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
292 } |
5582 | 293 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
294 retval = new_retval; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
295 } |
5582 | 296 } |
297 | |
298 return retval; | |
299 } | |
300 | |
6361 | 301 static octave_value_list |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
302 octcellregexp (const octave_value_list &args, int nargout, |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
303 const std::string &who, bool case_insensitive = false) |
6361 | 304 { |
305 octave_value_list retval; | |
306 | |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
307 if (args(0).is_cell ()) |
6361 | 308 { |
309 OCTAVE_LOCAL_BUFFER (Cell, newretval, nargout); | |
310 octave_value_list new_args = args; | |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
311 Cell cellstr = args(0).cell_value (); |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
312 if (args(1).is_cell ()) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
313 { |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
314 Cell cellpat = args(1).cell_value (); |
6361 | 315 |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
316 if (cellpat.numel () == 1) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
317 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
318 for (int j = 0; j < nargout; j++) |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
319 newretval[j].resize (cellstr.dims ()); |
6361 | 320 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
321 new_args(1) = cellpat(0); |
6361 | 322 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
323 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
|
324 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
325 new_args(0) = cellstr(i); |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
326 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
|
327 case_insensitive); |
6361 | 328 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
329 if (error_state) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
330 break; |
6361 | 331 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
332 for (int j = 0; j < nargout; j++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
333 newretval[j](i) = tmp(j); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
334 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
335 } |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
336 else if (cellstr.numel () == 1) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
337 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
338 for (int j = 0; j < nargout; j++) |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
339 newretval[j].resize (cellpat.dims ()); |
6361 | 340 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
341 new_args(0) = cellstr(0); |
6361 | 342 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
343 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
|
344 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
345 new_args(1) = cellpat(i); |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
346 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
|
347 case_insensitive); |
6361 | 348 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
349 if (error_state) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
350 break; |
6361 | 351 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
352 for (int j = 0; j < nargout; j++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
353 newretval[j](i) = tmp(j); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
354 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
355 } |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
356 else if (cellstr.numel () == cellpat.numel ()) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
357 { |
6361 | 358 |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
359 if (cellstr.dims () != cellpat.dims ()) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
360 error ("%s: inconsistent cell array dimensions", who.c_str ()); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
361 else |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
362 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
363 for (int j = 0; j < nargout; j++) |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
364 newretval[j].resize (cellstr.dims ()); |
6361 | 365 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
366 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
|
367 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
368 new_args(0) = cellstr(i); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
369 new_args(1) = cellpat(i); |
6361 | 370 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
371 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
|
372 case_insensitive); |
6361 | 373 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
374 if (error_state) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
375 break; |
6361 | 376 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
377 for (int j = 0; j < nargout; j++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
378 newretval[j](i) = tmp(j); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
379 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
380 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
381 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
382 else |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
383 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
|
384 } |
6361 | 385 else |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
386 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
387 for (int j = 0; j < nargout; j++) |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
388 newretval[j].resize (cellstr.dims ()); |
6361 | 389 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
390 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
|
391 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
392 new_args(0) = cellstr(i); |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
393 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
|
394 case_insensitive); |
6361 | 395 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
396 if (error_state) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
397 break; |
6361 | 398 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
399 for (int j = 0; j < nargout; j++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
400 newretval[j](i) = tmp(j); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
401 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
402 } |
6361 | 403 |
404 if (!error_state) | |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
405 for (int j = 0; j < nargout; j++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
406 retval(j) = octave_value (newretval[j]); |
6361 | 407 } |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
408 else if (args(1).is_cell ()) |
6361 | 409 { |
410 OCTAVE_LOCAL_BUFFER (Cell, newretval, nargout); | |
411 octave_value_list new_args = args; | |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
412 Cell cellpat = args(1).cell_value (); |
6361 | 413 |
414 for (int j = 0; j < nargout; j++) | |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
415 newretval[j].resize(cellpat.dims ()); |
6361 | 416 |
417 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
|
418 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
419 new_args(1) = cellpat(i); |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
420 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
|
421 case_insensitive); |
6361 | 422 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
423 if (error_state) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
424 break; |
6361 | 425 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
426 for (int j = 0; j < nargout; j++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
427 newretval[j](i) = tmp(j); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
428 } |
6361 | 429 |
430 if (!error_state) | |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
431 { |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
432 for (int j = 0; j < nargout; j++) |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
433 retval(j) = octave_value (newretval[j]); |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
434 } |
6361 | 435 } |
436 else | |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
437 retval = octregexp (args, nargout, who, case_insensitive); |
6361 | 438 |
439 return retval; | |
440 | |
441 } | |
442 | |
5582 | 443 DEFUN_DLD (regexp, args, nargout, |
444 "-*- texinfo -*-\n\ | |
14496
bd592d5482c0
doc: Add SP to list of outputs in docstring for regexp, regexpi.
Rik <octave@nomad.inbox5.com>
parents:
14454
diff
changeset
|
445 @deftypefn {Loadable Function} {[@var{s}, @var{e}, @var{te}, @var{m}, @var{t}, @var{nm}, @var{sp}] =} regexp (@var{str}, @var{pat})\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
446 @deftypefnx {Loadable Function} {[@dots{}] =} regexp (@var{str}, @var{pat}, \"@var{opt1}\", @dots{})\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
447 Regular expression string matching. Search for @var{pat} in @var{str} and\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
448 return the positions and substrings of any matches, or empty values if there\n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
449 are none.\n\ |
5582 | 450 \n\ |
451 The matched pattern @var{pat} can include any of the standard regex\n\ | |
452 operators, including:\n\ | |
453 \n\ | |
454 @table @code\n\ | |
455 @item .\n\ | |
456 Match any character\n\ | |
10840 | 457 \n\ |
5582 | 458 @item * + ? @{@}\n\ |
459 Repetition operators, representing\n\ | |
14366
b76f0740940e
doc: Periodic grammar check of documentation.
Rik <octave@nomad.inbox5.com>
parents:
14360
diff
changeset
|
460 \n\ |
5582 | 461 @table @code\n\ |
462 @item *\n\ | |
463 Match zero or more times\n\ | |
10840 | 464 \n\ |
5582 | 465 @item +\n\ |
466 Match one or more times\n\ | |
10840 | 467 \n\ |
5582 | 468 @item ?\n\ |
469 Match zero or one times\n\ | |
10840 | 470 \n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
471 @item @{@var{n}@}\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
472 Match exactly @var{n} times\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
473 \n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
474 @item @{@var{n},@}\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
475 Match @var{n} or more times\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
476 \n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
477 @item @{@var{m},@var{n}@}\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
478 Match between @var{m} and @var{n} times\n\ |
5582 | 479 @end table\n\ |
10840 | 480 \n\ |
5582 | 481 @item [@dots{}] [^@dots{}]\n\ |
10840 | 482 \n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
483 List operators. The pattern will match any character listed between \"[\"\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
484 and \"]\". If the first character is \"^\" then the pattern is inverted and\n\ |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
485 any character except those listed between brackets will match.\n\ |
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
486 \n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
487 Escape sequences defined below can also be used inside list\n\ |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
488 operators. For example, a template for a floating point number might be\n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
489 @code{[-+.\\d]+}.\n\ |
10840 | 490 \n\ |
5582 | 491 @item ()\n\ |
492 Grouping operator\n\ | |
10840 | 493 \n\ |
5582 | 494 @item |\n\ |
9036
58604c45ca74
Cleanup of data types related documentation
Rik <rdrider0-list@yahoo.com>
parents:
8920
diff
changeset
|
495 Alternation operator. Match one of a choice of regular expressions. The\n\ |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
496 alternatives must be delimited by the grouping operator @code{()} above.\n\ |
10840 | 497 \n\ |
5582 | 498 @item ^ $\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
499 Anchoring operators. Requires pattern to occur at the start (@code{^}) or\n\ |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
500 end (@code{$}) of the string.\n\ |
5582 | 501 @end table\n\ |
502 \n\ | |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
503 In addition, the following escaped characters have special meaning. Note,\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
504 it is recommended to quote @var{pat} in single quotes, rather than double\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
505 quotes, to avoid the escape sequences being interpreted by Octave before\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
506 being passed to @code{regexp}.\n\ |
5582 | 507 \n\ |
508 @table @code\n\ | |
509 @item \\b\n\ | |
510 Match a word boundary\n\ | |
10840 | 511 \n\ |
5582 | 512 @item \\B\n\ |
513 Match within a word\n\ | |
10840 | 514 \n\ |
5582 | 515 @item \\w\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
516 Match any word character\n\ |
10840 | 517 \n\ |
5582 | 518 @item \\W\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
519 Match any non-word character\n\ |
10840 | 520 \n\ |
5582 | 521 @item \\<\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
522 Match the beginning of a word\n\ |
10840 | 523 \n\ |
5582 | 524 @item \\>\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
525 Match the end of a word\n\ |
10840 | 526 \n\ |
5582 | 527 @item \\s\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
528 Match any whitespace character\n\ |
10840 | 529 \n\ |
5582 | 530 @item \\S\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
531 Match any non-whitespace character\n\ |
10840 | 532 \n\ |
5582 | 533 @item \\d\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
534 Match any digit\n\ |
10840 | 535 \n\ |
5582 | 536 @item \\D\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
537 Match any non-digit\n\ |
5582 | 538 @end table\n\ |
539 \n\ | |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
540 The outputs of @code{regexp} default to the order given below\n\ |
5582 | 541 \n\ |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
542 @table @var\n\ |
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
543 @item s\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
544 The start indices of each matching substring\n\ |
5582 | 545 \n\ |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
546 @item e\n\ |
5582 | 547 The end indices of each matching substring\n\ |
548 \n\ | |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
549 @item te\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
550 The extents of each matched token surrounded by @code{(@dots{})} in\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
551 @var{pat}\n\ |
5582 | 552 \n\ |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
553 @item m\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
554 A cell array of the text of each match\n\ |
5582 | 555 \n\ |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
556 @item t\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
557 A cell array of the text of each token matched\n\ |
5582 | 558 \n\ |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
559 @item nm\n\ |
5582 | 560 A structure containing the text of each matched named token, with the name\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
561 being used as the fieldname. A named token is denoted by\n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
562 @code{(?<name>@dots{})}.\n\ |
13929
9cae456085c2
Grammarcheck of documentation before 3.6.0 release.
Rik <octave@nomad.inbox5.com>
parents:
13759
diff
changeset
|
563 \n\ |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
564 @item sp\n\ |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
565 A cell array of the text not returned by match.\n\ |
5582 | 566 @end table\n\ |
567 \n\ | |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
568 Particular output arguments, or the order of the output arguments, can be\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
569 selected by additional @var{opt} arguments. These are strings and the\n\ |
5582 | 570 correspondence between the output arguments and the optional argument\n\ |
571 are\n\ | |
572 \n\ | |
573 @multitable @columnfractions 0.2 0.3 0.3 0.2\n\ | |
574 @item @tab 'start' @tab @var{s} @tab\n\ | |
575 @item @tab 'end' @tab @var{e} @tab\n\ | |
576 @item @tab 'tokenExtents' @tab @var{te} @tab\n\ | |
577 @item @tab 'match' @tab @var{m} @tab\n\ | |
578 @item @tab 'tokens' @tab @var{t} @tab\n\ | |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
579 @item @tab 'names' @tab @var{nm} @tab\n\ |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
580 @item @tab 'split' @tab @var{sp} @tab\n\ |
5582 | 581 @end multitable\n\ |
582 \n\ | |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
583 Additional arguments are summarized below.\n\ |
5779 | 584 \n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
585 @table @samp\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
586 @item once\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
587 Return only the first occurrence of the pattern.\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
588 \n\ |
5779 | 589 @item matchcase\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
590 Make the matching case sensitive. (default)\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
591 \n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
592 Alternatively, use (?-i) in the pattern.\n\ |
10840 | 593 \n\ |
5779 | 594 @item ignorecase\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
595 Ignore case when matching the pattern to the string.\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
596 \n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
597 Alternatively, use (?i) in the pattern.\n\ |
10840 | 598 \n\ |
5779 | 599 @item stringanchors\n\ |
12642
f96b9b9f141b
doc: Periodic grammarcheck and spellcheck of documentation.
Rik <octave@nomad.inbox5.com>
parents:
12464
diff
changeset
|
600 Match the anchor characters at the beginning and end of the string.\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
601 (default)\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
602 \n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
603 Alternatively, use (?-m) in the pattern.\n\ |
10840 | 604 \n\ |
5779 | 605 @item lineanchors\n\ |
606 Match the anchor characters at the beginning and end of the line.\n\ | |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
607 \n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
608 Alternatively, use (?m) in the pattern.\n\ |
10840 | 609 \n\ |
5779 | 610 @item dotall\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
611 The pattern @code{.} matches all characters including the newline character.\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
612 (default)\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
613 \n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
614 Alternatively, use (?s) in the pattern.\n\ |
10840 | 615 \n\ |
5779 | 616 @item dotexceptnewline\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
617 The pattern @code{.} matches all characters except the newline character.\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
618 \n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
619 Alternatively, use (?-s) in the pattern.\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
620 \n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
621 @item literalspacing\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
622 All characters in the pattern, including whitespace, are significant and are\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
623 used in pattern matching. (default)\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
624 \n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
625 Alternatively, use (?-x) in the pattern.\n\ |
10840 | 626 \n\ |
5779 | 627 @item freespacing\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
628 The pattern may include arbitrary whitespace and also comments beginning with\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
629 the character @samp{#}.\n\ |
10840 | 630 \n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
631 Alternatively, use (?x) in the pattern.\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
632 \n\ |
5779 | 633 @end table\n\ |
11572
7d6d8c1e471f
Grammarcheck Texinfo for files in src directory.
Rik <octave@nomad.inbox5.com>
parents:
11553
diff
changeset
|
634 @seealso{regexpi, strfind, regexprep}\n\ |
5582 | 635 @end deftypefn") |
636 { | |
6361 | 637 octave_value_list retval; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
638 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
639 int nargin = args.length (); |
6361 | 640 |
641 if (nargin < 2) | |
642 print_usage (); | |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
643 else if (args(0).is_cell () || args(1).is_cell ()) |
14454
2232931f2494
Return regexp output when input is a cellstr and there is no return variable assignment.
Rik <octave@nomad.inbox5.com>
parents:
14453
diff
changeset
|
644 retval = octcellregexp (args, (nargout > 0 ? nargout : 1), "regexp"); |
6361 | 645 else |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
646 retval = octregexp (args, nargout, "regexp"); |
6361 | 647 |
648 return retval; | |
5582 | 649 } |
650 | |
651 /* | |
652 | |
8140
cdd05e46f6c9
Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents:
8093
diff
changeset
|
653 ## PCRE_ERROR_MATCHLIMIT test |
cdd05e46f6c9
Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents:
8093
diff
changeset
|
654 %!test |
cdd05e46f6c9
Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents:
8093
diff
changeset
|
655 %! 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-'); |
cdd05e46f6c9
Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents:
8093
diff
changeset
|
656 %! ws = warning("query"); |
cdd05e46f6c9
Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents:
8093
diff
changeset
|
657 %! unwind_protect |
cdd05e46f6c9
Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents:
8093
diff
changeset
|
658 %! warning("off"); |
cdd05e46f6c9
Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents:
8093
diff
changeset
|
659 %! regexp(s, '(\s*-*\d+[.]*\d*\s*)+\n'); |
cdd05e46f6c9
Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents:
8093
diff
changeset
|
660 %! unwind_protect_cleanup |
cdd05e46f6c9
Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents:
8093
diff
changeset
|
661 %! warning(ws); |
cdd05e46f6c9
Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents:
8093
diff
changeset
|
662 %! end_unwind_protect |
cdd05e46f6c9
Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents:
8093
diff
changeset
|
663 |
5582 | 664 ## seg-fault test |
665 %!assert(regexp("abcde","."),[1,2,3,4,5]) | |
13759
c4b6ea833fa5
Fix infinite loop with null patterns in regexp (Bug #34101, Bug #33258)
Rik <octave@nomad.inbox5.com>
parents:
13311
diff
changeset
|
666 ## Infinite loop test |
c4b6ea833fa5
Fix infinite loop with null patterns in regexp (Bug #34101, Bug #33258)
Rik <octave@nomad.inbox5.com>
parents:
13311
diff
changeset
|
667 %!assert (isempty (regexp("abcde", ""))) |
5582 | 668 |
669 ## Check that anchoring of pattern works correctly | |
670 %!assert(regexp('abcabc','^abc'),1); | |
671 %!assert(regexp('abcabc','abc$'),4); | |
5785 | 672 %!assert(regexp('abcabc','^abc$'),zeros(1,0)); |
5582 | 673 |
674 %!test | |
675 %! [s, e, te, m, t] = regexp(' No Match ', 'f(.*)uck'); | |
5785 | 676 %! assert (s,zeros(1,0)) |
677 %! assert (e,zeros(1,0)) | |
678 %! assert (te,cell(1,0)) | |
679 %! assert (m, cell(1,0)) | |
680 %! assert (t, cell(1,0)) | |
5582 | 681 |
682 %!test | |
683 %! [s, e, te, m, t] = regexp(' FiRetrUck ', 'f(.*)uck'); | |
5785 | 684 %! assert (s,zeros(1,0)) |
685 %! assert (e,zeros(1,0)) | |
686 %! assert (te,cell(1,0)) | |
687 %! assert (m, cell(1,0)) | |
688 %! assert (t, cell(1,0)) | |
5582 | 689 |
690 %!test | |
691 %! [s, e, te, m, t] = regexp(' firetruck ', 'f(.*)uck'); | |
692 %! assert (s,2) | |
693 %! assert (e,10) | |
694 %! assert (te{1},[3,7]) | |
695 %! assert (m{1}, 'firetruck') | |
696 %! assert (t{1}{1}, 'iretr') | |
697 | |
698 %!test | |
699 %! [s, e, te, m, t] = regexp('short test string','\w*r\w*'); | |
700 %! assert (s,[1,12]) | |
701 %! assert (e,[5,17]) | |
702 %! assert (size(te), [1,2]) | |
703 %! assert (isempty(te{1})) | |
704 %! assert (isempty(te{2})) | |
705 %! assert (m{1},'short') | |
706 %! assert (m{2},'string') | |
707 %! assert (size(t), [1,2]) | |
708 %! assert (isempty(t{1})) | |
709 %! assert (isempty(t{2})) | |
710 | |
711 %!test | |
712 %! [s, e, te, m, t] = regexp('short test string','\w*r\w*','once'); | |
713 %! assert (s,1) | |
714 %! assert (e,5) | |
7893
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
715 %! assert (isempty(te)) |
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
716 %! assert (m,'short') |
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
717 %! assert (isempty(t)) |
5582 | 718 |
719 %!test | |
720 %! [m, te, e, s, t] = regexp('short test string','\w*r\w*','once', 'match', 'tokenExtents', 'end', 'start', 'tokens'); | |
721 %! assert (s,1) | |
722 %! assert (e,5) | |
7893
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
723 %! assert (isempty(te)) |
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
724 %! assert (m,'short') |
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
725 %! assert (isempty(t)) |
5582 | 726 |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
727 %!test |
7242 | 728 %! [s, e, te, m, t, nm] = regexp('short test string','(?<word1>\w*t)\s*(?<word2>\w*t)'); |
729 %! assert (s,1) | |
730 %! assert (e,10) | |
731 %! assert (size(te), [1,1]) | |
732 %! assert (te{1}, [1 5; 7, 10]) | |
733 %! assert (m{1},'short test') | |
734 %! assert (size(t),[1,1]) | |
735 %! assert (t{1}{1},'short') | |
736 %! assert (t{1}{2},'test') | |
737 %! assert (size(nm), [1,1]) | |
738 %! assert (!isempty(fieldnames(nm))) | |
739 %! assert (sort(fieldnames(nm)),{'word1';'word2'}) | |
740 %! assert (nm.word1,'short') | |
741 %! assert (nm.word2,'test') | |
5582 | 742 |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
743 %!test |
7242 | 744 %! [nm, m, te, e, s, t] = regexp('short test string','(?<word1>\w*t)\s*(?<word2>\w*t)', 'names', 'match', 'tokenExtents', 'end', 'start', 'tokens'); |
745 %! assert (s,1) | |
746 %! assert (e,10) | |
747 %! assert (size(te), [1,1]) | |
748 %! assert (te{1}, [1 5; 7, 10]) | |
749 %! assert (m{1},'short test') | |
750 %! assert (size(t),[1,1]) | |
751 %! assert (t{1}{1},'short') | |
752 %! assert (t{1}{2},'test') | |
753 %! assert (size(nm), [1,1]) | |
754 %! assert (!isempty(fieldnames(nm))) | |
755 %! assert (sort(fieldnames(nm)),{'word1';'word2'}) | |
756 %! assert (nm.word1,'short') | |
757 %! assert (nm.word2,'test') | |
5619 | 758 |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
759 %!test |
7242 | 760 %! [t, nm] = regexp("John Davis\nRogers, James",'(?<first>\w+)\s+(?<last>\w+)|(?<last>\w+),\s+(?<first>\w+)','tokens','names'); |
761 %! assert (size(t), [1,2]); | |
762 %! assert (t{1}{1},'John'); | |
763 %! assert (t{1}{2},'Davis'); | |
764 %! assert (t{2}{1},'Rogers'); | |
765 %! assert (t{2}{2},'James'); | |
766 %! assert (size(nm), [1,1]); | |
767 %! assert (nm.first{1},'John'); | |
768 %! assert (nm.first{2},'James'); | |
769 %! assert (nm.last{1},'Davis'); | |
770 %! assert (nm.last{2},'Rogers'); | |
5582 | 771 |
14452
721be41ea988
Stop segfault when using regular expressions with named capture buffers (bug #35683).
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
772 ## Tests for named tokens |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
773 %!test |
10518
fcafe0e9bd58
Handle repeated matches in matches returned by pcre
David Bateman <dbateman@free.fr>
parents:
10504
diff
changeset
|
774 %! # Parenthesis in named token (ie (int)) causes a problem |
fcafe0e9bd58
Handle repeated matches in matches returned by pcre
David Bateman <dbateman@free.fr>
parents:
10504
diff
changeset
|
775 %! assert (regexp('qwe int asd', ['(?<typestr>(int))'], 'names'), struct ('typestr', 'int')); |
fcafe0e9bd58
Handle repeated matches in matches returned by pcre
David Bateman <dbateman@free.fr>
parents:
10504
diff
changeset
|
776 |
14452
721be41ea988
Stop segfault when using regular expressions with named capture buffers (bug #35683).
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
777 %!test |
721be41ea988
Stop segfault when using regular expressions with named capture buffers (bug #35683).
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
778 %! ## Mix of named and unnamed tokens can cause segfault (bug #35683) |
721be41ea988
Stop segfault when using regular expressions with named capture buffers (bug #35683).
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
779 %! str = "abcde"; |
721be41ea988
Stop segfault when using regular expressions with named capture buffers (bug #35683).
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
780 %! 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
|
781 %! 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
|
782 %! 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
|
783 %! 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
|
784 %! 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
|
785 |
5779 | 786 %!assert(regexp("abc\nabc",'.'),[1:7]) |
787 %!assert(regexp("abc\nabc",'.','dotall'),[1:7]) | |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
788 %!test |
7242 | 789 %! assert(regexp("abc\nabc",'(?s).'),[1:7]) |
790 %! assert(regexp("abc\nabc",'.','dotexceptnewline'),[1,2,3,5,6,7]) | |
791 %! assert(regexp("abc\nabc",'(?-s).'),[1,2,3,5,6,7]) | |
5779 | 792 |
793 %!assert(regexp("caseCaSe",'case'),1) | |
794 %!assert(regexp("caseCaSe",'case',"matchcase"),1) | |
795 %!assert(regexp("caseCaSe",'case',"ignorecase"),[1,5]) | |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
796 %!test |
7242 | 797 %! assert(regexp("caseCaSe",'(?-i)case'),1) |
798 %! assert(regexp("caseCaSe",'(?i)case'),[1,5]) | |
5779 | 799 |
800 %!assert (regexp("abc\nabc",'c$'),7) | |
801 %!assert (regexp("abc\nabc",'c$',"stringanchors"),7) | |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
802 %!test |
7242 | 803 %! assert (regexp("abc\nabc",'(?-m)c$'),7) |
804 %! assert (regexp("abc\nabc",'c$',"lineanchors"),[3,7]) | |
805 %! assert (regexp("abc\nabc",'(?m)c$'),[3,7]) | |
5779 | 806 |
807 %!assert (regexp("this word",'s w'),4) | |
808 %!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
|
809 %!test |
7242 | 810 %! assert (regexp("this word",'(?-x)s w','literalspacing'),4) |
811 %! assert (regexp("this word",'s w','freespacing'),zeros(1,0)) | |
812 %! assert (regexp("this word",'(?x)s w'),zeros(1,0)) | |
5779 | 813 |
5582 | 814 %!error regexp('string', 'tri', 'BadArg'); |
815 %!error regexp('string'); | |
816 | |
6361 | 817 %!assert(regexp({'asdfg-dfd';'-dfd-dfd-';'qasfdfdaq'},'-'),{6;[1,5,9];zeros(1,0)}) |
818 %!assert(regexp({'asdfg-dfd','-dfd-dfd-','qasfdfdaq'},'-'),{6,[1,5,9],zeros(1,0)}) | |
819 %!assert(regexp({'asdfg-dfd';'-dfd-dfd-';'qasfdfdaq'},{'-';'f';'q'}),{6;[3,7];[1,9]}) | |
820 %!assert(regexp('Strings',{'t','s'}),{2,7}) | |
821 | |
8093
dcc31f473596
Treat PCRE lookbehind operators in a manner that is approximately correct
David Bateman <dbateman@free.fr>
parents:
8021
diff
changeset
|
822 ## Test case for lookaround operators |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
823 %!test |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
824 %! assert(regexp('Iraq','q(?!u)'),4) |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
825 %! assert(regexp('quit','q(?!u)'), zeros(1,0)) |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
826 %! assert(regexp('quit','q(?=u)','match'), {'q'}) |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
827 %! assert(regexp("quit",'q(?=u+)','match'), {'q'}) |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
828 %! assert(regexp("qit",'q(?=u+)','match'), cell(1,0)) |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
829 %! assert(regexp("qit",'q(?=u*)','match'), {'q'}) |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
830 %! 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
|
831 |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
832 ## Tests for split option. |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
833 %!shared str |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
834 %! str = "foo bar foo"; |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
835 %!test |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
836 %! [a, b] = regexp (str, "f..", "match", "split"); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
837 %! assert (a, {"foo", "foo"}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
838 %! assert (b, {"", " bar ", ""}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
839 %!test |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
840 %! [a, b] = regexp (str, "f..", "match", "split", "once"); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
841 %! assert (a, "foo"); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
842 %! assert (b, {"", " bar foo"}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
843 %!test |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
844 %! [a, b] = regexp (str, "fx.", "match", "split"); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
845 %! assert (a, cell (1, 0)); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
846 %! assert (b, {"foo bar foo"}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
847 %!test |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
848 %! [a, b] = regexp (str, "fx.", "match", "split", "once"); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
849 %! assert (a, ""); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
850 %! assert (b, "foo bar foo") |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
851 |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
852 %!shared str |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
853 %! str = "foo bar"; |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
854 %!test |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
855 %! [a, b] = regexp (str, "f..", "match", "split"); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
856 %! assert (a, {"foo"}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
857 %! assert (b, {"", " bar"}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
858 %!test |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
859 %! [a, b] = regexp (str, "b..", "match", "split"); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
860 %! assert (a, {"bar"}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
861 %! assert (b, {"foo ", ""}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
862 %!test |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
863 %! [a, b] = regexp (str, "x", "match", "split"); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
864 %! assert (a, cell (1, 0)); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
865 %! assert (b, {"foo bar"}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
866 %!test |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
867 %! [a, b] = regexp (str, "[o]+", "match", "split"); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
868 %! assert (a, {"oo"}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
869 %! assert (b, {"f", " bar"}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
870 |
5582 | 871 */ |
872 | |
6549 | 873 DEFUN_DLD (regexpi, args, nargout, |
5582 | 874 "-*- texinfo -*-\n\ |
14496
bd592d5482c0
doc: Add SP to list of outputs in docstring for regexp, regexpi.
Rik <octave@nomad.inbox5.com>
parents:
14454
diff
changeset
|
875 @deftypefn {Loadable Function} {[@var{s}, @var{e}, @var{te}, @var{m}, @var{t}, @var{nm}, @var{sp}] =} regexpi (@var{str}, @var{pat})\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
876 @deftypefnx {Loadable Function} {[@dots{}] =} regexpi (@var{str}, @var{pat}, \"@var{opt1}\", @dots{})\n\ |
5582 | 877 \n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
878 Case insensitive regular expression string matching. Search for @var{pat} in\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
879 @var{str} and return the positions and substrings of any matches, or empty\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
880 values if there are none. @xref{doc-regexp,,regexp}, for details on the\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
881 syntax of the search pattern.\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
882 @seealso{regexp}\n\ |
5582 | 883 @end deftypefn") |
884 { | |
6361 | 885 octave_value_list retval; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
886 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
887 int nargin = args.length (); |
6361 | 888 |
889 if (nargin < 2) | |
890 print_usage (); | |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
891 else if (args(0).is_cell () || args(1).is_cell ()) |
14454
2232931f2494
Return regexp output when input is a cellstr and there is no return variable assignment.
Rik <octave@nomad.inbox5.com>
parents:
14453
diff
changeset
|
892 retval = octcellregexp (args, (nargout > 0 ? nargout : 1), "regexpi", true); |
6361 | 893 else |
894 retval = octregexp (args, nargout, "regexpi", true); | |
895 | |
896 return retval; | |
5582 | 897 } |
898 | |
899 /* | |
900 | |
901 ## seg-fault test | |
902 %!assert(regexpi("abcde","."),[1,2,3,4,5]) | |
903 | |
904 ## Check that anchoring of pattern works correctly | |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
905 %!assert(regexpi('abcabc','^ABC'),1); |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
906 %!assert(regexpi('abcabc','ABC$'),4); |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
907 %!assert(regexpi('abcabc','^ABC$'),zeros(1,0)); |
5582 | 908 |
909 %!test | |
910 %! [s, e, te, m, t] = regexpi(' No Match ', 'f(.*)uck'); | |
5785 | 911 %! assert (s,zeros(1,0)) |
912 %! assert (e,zeros(1,0)) | |
913 %! assert (te,cell(1,0)) | |
914 %! assert (m, cell(1,0)) | |
915 %! assert (t, cell(1,0)) | |
5582 | 916 |
917 %!test | |
918 %! [s, e, te, m, t] = regexpi(' FiRetrUck ', 'f(.*)uck'); | |
919 %! assert (s,2) | |
920 %! assert (e,10) | |
921 %! assert (te{1},[3,7]) | |
922 %! assert (m{1}, 'FiRetrUck') | |
923 %! assert (t{1}{1}, 'iRetr') | |
924 | |
925 %!test | |
926 %! [s, e, te, m, t] = regexpi(' firetruck ', 'f(.*)uck'); | |
927 %! assert (s,2) | |
928 %! assert (e,10) | |
929 %! assert (te{1},[3,7]) | |
930 %! assert (m{1}, 'firetruck') | |
931 %! assert (t{1}{1}, 'iretr') | |
932 | |
933 %!test | |
934 %! [s, e, te, m, t] = regexpi('ShoRt Test String','\w*r\w*'); | |
935 %! assert (s,[1,12]) | |
936 %! assert (e,[5,17]) | |
937 %! assert (size(te), [1,2]) | |
938 %! assert (isempty(te{1})) | |
939 %! assert (isempty(te{2})) | |
940 %! assert (m{1},'ShoRt') | |
941 %! assert (m{2},'String') | |
942 %! assert (size(t), [1,2]) | |
943 %! assert (isempty(t{1})) | |
944 %! assert (isempty(t{2})) | |
945 | |
946 %!test | |
947 %! [s, e, te, m, t] = regexpi('ShoRt Test String','\w*r\w*','once'); | |
948 %! assert (s,1) | |
949 %! assert (e,5) | |
7893
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
950 %! assert (isempty(te)) |
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
951 %! assert (m,'ShoRt') |
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
952 %! assert (isempty(t)) |
5582 | 953 |
954 %!test | |
955 %! [m, te, e, s, t] = regexpi('ShoRt Test String','\w*r\w*','once', 'match', 'tokenExtents', 'end', 'start', 'tokens'); | |
956 %! assert (s,1) | |
957 %! assert (e,5) | |
7893
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
958 %! assert (isempty(te)) |
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
959 %! assert (m,'ShoRt') |
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
960 %! assert (isempty(t)) |
5582 | 961 |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
962 %!test |
7242 | 963 %! [s, e, te, m, t, nm] = regexpi('ShoRt Test String','(?<word1>\w*t)\s*(?<word2>\w*t)'); |
964 %! assert (s,1) | |
965 %! assert (e,10) | |
966 %! assert (size(te), [1,1]) | |
967 %! assert (te{1}, [1 5; 7, 10]) | |
968 %! assert (m{1},'ShoRt Test') | |
969 %! assert (size(t),[1,1]) | |
970 %! assert (t{1}{1},'ShoRt') | |
971 %! assert (t{1}{2},'Test') | |
972 %! assert (size(nm), [1,1]) | |
973 %! assert (!isempty(fieldnames(nm))) | |
974 %! assert (sort(fieldnames(nm)),{'word1';'word2'}) | |
975 %! assert (nm.word1,'ShoRt') | |
976 %! assert (nm.word2,'Test') | |
5582 | 977 |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
978 %!test |
7242 | 979 %! [nm, m, te, e, s, t] = regexpi('ShoRt Test String','(?<word1>\w*t)\s*(?<word2>\w*t)', 'names', 'match', 'tokenExtents', 'end', 'start', 'tokens'); |
980 %! assert (s,1) | |
981 %! assert (e,10) | |
982 %! assert (size(te), [1,1]) | |
983 %! assert (te{1}, [1 5; 7, 10]) | |
984 %! assert (m{1},'ShoRt Test') | |
985 %! assert (size(t),[1,1]) | |
986 %! assert (t{1}{1},'ShoRt') | |
987 %! assert (t{1}{2},'Test') | |
988 %! assert (size(nm), [1,1]) | |
989 %! assert (!isempty(fieldnames(nm))) | |
990 %! assert (sort(fieldnames(nm)),{'word1';'word2'}) | |
991 %! assert (nm.word1,'ShoRt') | |
992 %! assert (nm.word2,'Test') | |
5582 | 993 |
5779 | 994 %!assert(regexpi("abc\nabc",'.'),[1:7]) |
995 %!assert(regexpi("abc\nabc",'.','dotall'),[1:7]) | |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
996 %!test |
7242 | 997 %! assert(regexpi("abc\nabc",'(?s).'),[1:7]) |
998 %! assert(regexpi("abc\nabc",'.','dotexceptnewline'),[1,2,3,5,6,7]) | |
999 %! assert(regexpi("abc\nabc",'(?-s).'),[1,2,3,5,6,7]) | |
5779 | 1000 |
1001 %!assert(regexpi("caseCaSe",'case'),[1,5]) | |
1002 %!assert(regexpi("caseCaSe",'case',"matchcase"),1) | |
1003 %!assert(regexpi("caseCaSe",'case',"ignorecase"),[1,5]) | |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
1004 %!test |
7242 | 1005 %! assert(regexpi("caseCaSe",'(?-i)case'),1) |
1006 %! assert(regexpi("caseCaSe",'(?i)case'),[1,5]) | |
5779 | 1007 |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1008 %!assert (regexpi("abc\nabc",'C$'),7) |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1009 %!assert (regexpi("abc\nabc",'C$',"stringanchors"),7) |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
1010 %!test |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1011 %! assert (regexpi("abc\nabc",'(?-m)C$'),7) |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1012 %! assert (regexpi("abc\nabc",'C$',"lineanchors"),[3,7]) |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1013 %! assert (regexpi("abc\nabc",'(?m)C$'),[3,7]) |
5779 | 1014 |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1015 %!assert (regexpi("this word",'S w'),4) |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1016 %!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
|
1017 %!test |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1018 %! assert (regexpi("this word",'(?-x)S w','literalspacing'),4) |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1019 %! assert (regexpi("this word",'S w','freespacing'),zeros(1,0)) |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1020 %! assert (regexpi("this word",'(?x)S w'),zeros(1,0)) |
5779 | 1021 |
5582 | 1022 %!error regexpi('string', 'tri', 'BadArg'); |
1023 %!error regexpi('string'); | |
1024 | |
6361 | 1025 %!assert(regexpi({'asdfg-dfd';'-dfd-dfd-';'qasfdfdaq'},'-'),{6;[1,5,9];zeros(1,0)}) |
1026 %!assert(regexpi({'asdfg-dfd','-dfd-dfd-','qasfdfdaq'},'-'),{6,[1,5,9],zeros(1,0)}) | |
1027 %!assert(regexpi({'asdfg-dfd';'-dfd-dfd-';'qasfdfdaq'},{'-';'f';'q'}),{6;[3,7];[1,9]}) | |
1028 %!assert(regexpi('Strings',{'t','s'}),{2,[1,7]}) | |
1029 | |
5582 | 1030 */ |
1031 | |
6361 | 1032 |
1033 static octave_value | |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1034 octregexprep (const octave_value_list &args, const std::string &who) |
5785 | 1035 { |
6361 | 1036 octave_value retval; |
5785 | 1037 |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1038 int nargin = args.length (); |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1039 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1040 // Make sure we have string, pattern, replacement |
5785 | 1041 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
|
1042 if (error_state) |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1043 return retval; |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1044 |
5785 | 1045 const std::string pattern = args(1).string_value (); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1046 if (error_state) |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1047 return retval; |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1048 |
5785 | 1049 const std::string replacement = args(2).string_value (); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1050 if (error_state) |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1051 return retval; |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11572
diff
changeset
|
1052 |
5785 | 1053 // Pack options excluding 'tokenize' and various output |
1054 // reordering strings into regexp arg list | |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1055 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
|
1056 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1057 int len = 0; |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11572
diff
changeset
|
1058 for (int i = 3; i < nargin; i++) |
5785 | 1059 { |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1060 const std::string opt = args(i).string_value (); |
5785 | 1061 if (opt != "tokenize" && opt != "start" && opt != "end" |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1062 && opt != "tokenextents" && opt != "match" && opt != "tokens" |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1063 && opt != "names" && opt != "split" && opt != "warnings") |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1064 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1065 regexpargs(len++) = args(i); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1066 } |
5785 | 1067 } |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1068 regexpargs.resize (len); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11572
diff
changeset
|
1069 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1070 regexp::opts options; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1071 bool extra_args = false; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1072 parse_options (options, regexpargs, who, 0, extra_args); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1073 if (error_state) |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1074 return retval; |
5785 | 1075 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1076 return regexp_replace (pattern, buffer, replacement, options, who); |
6361 | 1077 } |
1078 | |
6549 | 1079 DEFUN_DLD (regexprep, args, , |
6361 | 1080 "-*- texinfo -*-\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1081 @deftypefn {Loadable Function} {@var{outstr} =} regexprep (@var{string}, @var{pat}, @var{repstr})\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1082 @deftypefnx {Loadable Function} {@var{outstr} =} regexprep (@var{string}, @var{pat}, @var{repstr}, \"@var{opt1}\", @dots{})\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1083 Replace occurrences of pattern @var{pat} in @var{string} with @var{repstr}.\n\ |
6361 | 1084 \n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1085 The pattern is a regular expression as documented for @code{regexp}.\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1086 @xref{doc-regexp,,regexp}.\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1087 \n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1088 The replacement string may contain @code{$i}, which substitutes\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1089 for the ith set of parentheses in the match string. For example,\n\ |
10840 | 1090 \n\ |
6361 | 1091 @example\n\ |
14360
97883071e8e4
doc: Correct off-by-1 spacings in all .cc docstrings
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
1092 regexprep (\"Bill Dunn\", '(\\w+) (\\w+)', '$2, $1')\n\ |
6361 | 1093 @end example\n\ |
10840 | 1094 \n\ |
10846
a4f482e66b65
Grammarcheck more of the documentation.
Rik <octave@nomad.inbox5.com>
parents:
10840
diff
changeset
|
1095 @noindent\n\ |
6361 | 1096 returns \"Dunn, Bill\"\n\ |
1097 \n\ | |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1098 Options in addition to those of @code{regexp} are\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1099 \n\ |
6361 | 1100 @table @samp\n\ |
1101 \n\ | |
1102 @item once\n\ | |
7001 | 1103 Replace only the first occurrence of @var{pat} in the result.\n\ |
6361 | 1104 \n\ |
1105 @item warnings\n\ | |
1106 This option is present for compatibility but is ignored.\n\ | |
1107 \n\ | |
1108 @end table\n\ | |
11572
7d6d8c1e471f
Grammarcheck Texinfo for files in src directory.
Rik <octave@nomad.inbox5.com>
parents:
11553
diff
changeset
|
1109 @seealso{regexp, regexpi, strrep}\n\ |
6361 | 1110 @end deftypefn") |
1111 { | |
1112 octave_value_list retval; | |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1113 int nargin = args.length (); |
6361 | 1114 |
1115 if (nargin < 3) | |
1116 { | |
1117 print_usage (); | |
1118 return retval; | |
1119 } | |
1120 | |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1121 if (args(0).is_cell () || args(1).is_cell () || args(2).is_cell ()) |
6361 | 1122 { |
1123 Cell str; | |
1124 Cell pat; | |
1125 Cell rep; | |
6495 | 1126 dim_vector dv0; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1127 dim_vector dv1 (1, 1); |
6361 | 1128 |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1129 if (args(0).is_cell ()) |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1130 str = args(0).cell_value (); |
6361 | 1131 else |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1132 str = Cell (args(0)); |
6361 | 1133 |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1134 if (args(1).is_cell ()) |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1135 pat = args(1).cell_value (); |
6361 | 1136 else |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1137 pat = Cell (args(1)); |
6361 | 1138 |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1139 if (args(2).is_cell ()) |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1140 rep = args(2).cell_value (); |
6361 | 1141 else |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1142 rep = Cell (args(2)); |
6361 | 1143 |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1144 dv0 = str.dims (); |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1145 if (pat.numel () != 1) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1146 { |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1147 dv1 = pat.dims (); |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1148 if (rep.numel () != 1 && dv1 != rep.dims ()) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1149 error ("regexprep: inconsistent cell array dimensions"); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1150 } |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1151 else if (rep.numel () != 1) |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1152 dv1 = rep.dims (); |
6361 | 1153 |
1154 if (!error_state) | |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1155 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1156 Cell ret (dv0); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1157 octave_value_list new_args = args; |
6361 | 1158 |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1159 for (octave_idx_type i = 0; i < dv0.numel (); i++) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1160 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1161 new_args(0) = str(i); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1162 if (pat.numel() == 1) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1163 new_args(1) = pat(0); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1164 if (rep.numel() == 1) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1165 new_args(2) = rep(0); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1166 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1167 for (octave_idx_type j = 0; j < dv1.numel (); j++) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1168 { |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1169 if (pat.numel () != 1) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1170 new_args(1) = pat(j); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1171 if (rep.numel () != 1) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1172 new_args(2) = rep(j); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1173 new_args(0) = octregexprep (new_args, "regexprep"); |
6361 | 1174 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1175 if (error_state) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1176 break; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1177 } |
6361 | 1178 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1179 if (error_state) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1180 break; |
6495 | 1181 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1182 ret(i) = new_args(0); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1183 } |
6361 | 1184 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1185 if (!error_state) |
13311
d590d9df5596
regexprep: only return cell array if first arg is cell array
John W. Eaton <jwe@octave.org>
parents:
13310
diff
changeset
|
1186 retval = args(0).is_cell () |
d590d9df5596
regexprep: only return cell array if first arg is cell array
John W. Eaton <jwe@octave.org>
parents:
13310
diff
changeset
|
1187 ? octave_value (ret) : octave_value (ret(0)); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1188 } |
6361 | 1189 } |
1190 else | |
1191 retval = octregexprep (args, "regexprep"); | |
1192 | |
5785 | 1193 return retval; |
1194 } | |
1195 | |
1196 /* | |
1197 %!test # Replace with empty | |
1198 %! xml = '<!-- This is some XML --> <tag v="hello">some stuff<!-- sample tag--></tag>'; | |
1199 %! t = regexprep(xml,'<[!?][^>]*>',''); | |
1200 %! assert(t,' <tag v="hello">some stuff</tag>') | |
1201 | |
1202 %!test # Replace with non-empty | |
1203 %! xml = '<!-- This is some XML --> <tag v="hello">some stuff<!-- sample tag--></tag>'; | |
1204 %! t = regexprep(xml,'<[!?][^>]*>','?'); | |
1205 %! assert(t,'? <tag v="hello">some stuff?</tag>') | |
1206 | |
1207 %!test # Check that 'tokenize' is ignored | |
1208 %! xml = '<!-- This is some XML --> <tag v="hello">some stuff<!-- sample tag--></tag>'; | |
1209 %! t = regexprep(xml,'<[!?][^>]*>','','tokenize'); | |
1210 %! assert(t,' <tag v="hello">some stuff</tag>') | |
1211 | |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
1212 ## Test capture replacement |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
1213 %!test |
7242 | 1214 %! data = "Bob Smith\nDavid Hollerith\nSam Jenkins"; |
1215 %! result = "Smith, Bob\nHollerith, David\nJenkins, Sam"; | |
1216 %! t = regexprep(data,'(?m)^(\w+)\s+(\w+)$','$2, $1'); | |
1217 %! assert(t,result) | |
5785 | 1218 |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
1219 ## Return the original if no match |
5785 | 1220 %!assert(regexprep('hello','world','earth'),'hello') |
1221 | |
1222 ## Test a general replacement | |
1223 %!assert(regexprep("a[b]c{d}e-f=g", "[^A-Za-z0-9_]", "_"), "a_b_c_d_e_f_g"); | |
1224 | |
1225 ## Make sure it works at the beginning and end | |
1226 %!assert(regexprep("a[b]c{d}e-f=g", "a", "_"), "_[b]c{d}e-f=g"); | |
1227 %!assert(regexprep("a[b]c{d}e-f=g", "g", "_"), "a[b]c{d}e-f=_"); | |
1228 | |
1229 ## Options | |
1230 %!assert(regexprep("a[b]c{d}e-f=g", "[^A-Za-z0-9_]", "_", "once"), "a_b]c{d}e-f=g"); | |
1231 %!assert(regexprep("a[b]c{d}e-f=g", "[^A-Z0-9_]", "_", "ignorecase"), "a_b_c_d_e_f_g"); | |
1232 | |
1233 ## Option combinations | |
1234 %!assert(regexprep("a[b]c{d}e-f=g", "[^A-Z0-9_]", "_", "once", "ignorecase"), "a_b]c{d}e-f=g"); | |
1235 | |
1236 ## End conditions on replacement | |
1237 %!assert(regexprep("abc","(b)",".$1"),"a.bc"); | |
1238 %!assert(regexprep("abc","(b)","$1"),"abc"); | |
1239 %!assert(regexprep("abc","(b)","$1."),"ab.c"); | |
1240 %!assert(regexprep("abc","(b)","$1.."),"ab..c"); | |
1241 | |
6361 | 1242 ## Test cell array arguments |
13311
d590d9df5596
regexprep: only return cell array if first arg is cell array
John W. Eaton <jwe@octave.org>
parents:
13310
diff
changeset
|
1243 %!assert(regexprep("abc",{"b","a"},"?"),"??c") |
6361 | 1244 %!assert(regexprep({"abc","cba"},"b","?"),{"a?c","c?a"}) |
6503 | 1245 %!assert(regexprep({"abc","cba"},{"b","a"},{"?","!"}),{"!?c","c?!"}) |
6361 | 1246 |
8093
dcc31f473596
Treat PCRE lookbehind operators in a manner that is approximately correct
David Bateman <dbateman@free.fr>
parents:
8021
diff
changeset
|
1247 # Nasty lookbehind expression |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
1248 %!test |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1249 %! assert(regexprep('x^(-1)+y(-1)+z(-1)=0','(?<=[a-z]+)\(\-[1-9]*\)','_minus1'),'x^(-1)+y_minus1+z_minus1=0') |
8093
dcc31f473596
Treat PCRE lookbehind operators in a manner that is approximately correct
David Bateman <dbateman@free.fr>
parents:
8021
diff
changeset
|
1250 |
5785 | 1251 */ |