Mercurial > octave-nkf
annotate libinterp/corefcn/regexp.cc @ 19437:03067dab10ca
Use stricter input validation when looking for a string as input (bug #42651).
* data.cc (get_sort_mode_option, Fissorted): Use is_string() to check string
input.
* debug.cc (Fdbstep): use "string" rather than "character string" in error
messages.
* error.cc (Flasterr, Flastwarn): use "string" rather than "character string"
in error messages.
* file-io.cc (do_stream_open, do_fread, do_fwrite, Fpopen, Ftempname,
Fmkstemp): Use is_string() to check string input.
* graphics.cc (Fgraphics_toolkit): Use is_string() to check string input.
Rephrase error message.
* help.cc (F__list_functions): Use is_string() to check string input.
* input.cc (Fyes_or_no): Use is_string() to check string input. Rephrase
error message.
* input.cc (Fadd_input_event_hook): Rephrase error message.
* load-path.cc (Fgenpath, Faddpath): Rephrase error message.
* matrix_type.cc (Fmatrix_type): Use is_string() to check string input.
* qz.cc (Fqz): Follow Octave coding convention for space after '!'.
* regexp.cc (parse_options): Use is_string() to check string input.
Rephrase error message.
* schur.cc (Fschur): Use is_string() to check string input.
* strfns.cc (Flist_in_columns): Use is_string() to check string input.
Rephrase error message.
* symtab.cc (Fignore_function_time_stamp): Use is_string() to check string
input. Rephrase error message.
* syscalls.cc (Fexec, Fpopen2, Fcanonicalize_file_name): Use is_string() to
check string input. Rephrase error message.
* sysdep.cc (Fsetenv): Use is_string() to check string input.
* time.cc (Fstrftime, Fstrptime): Use is_string() to check string input.
* toplev.cc (Fsystem, Fatexit): Use is_string() to check string input.
* urlwrite.cc (Furlwrite, Furlread): Rephrase error message.
* utils.cc (Ffile_in_path): Use is_string() to check string input. Rephrase
error message.
* variables.cc (extract_function): Add FIXME about potentially using is_string.
* variables.cc (do_isglobal, Fmunlock, Fmislocked): Use is_string() to check
string input.
* variables.cc (set_internal_variable): Rephrase error message.
* ov-base.cc (make_idx_args): Rephrase error message.
* ov-class.cc (octave_class::all_strings, Fclass): Rephrase error message.
* ov-fcn-handle.cc (Fstr2func): Use is_string() to check string input
* ov-java.cc (FjavaObject, FjavaMethod, F__java_get__, F__java_set__):
Use is_string() to check string input.
* ov.cc (Fdecode_subscripts): Use is_string() to check string input.
Rephrase error message.
* pt-idx.cc (tree_index_expression::get_struct_index): Rephrase error message.
* io.tst: Change %!warning test to %!error test to match stricter checking.
* system.tst: Change %!warning test for setenv to %!error test to match
stricter checking.
author | Rik <rik@octave.org> |
---|---|
date | Tue, 16 Dec 2014 09:21:29 -0800 |
parents | 870f3e12e163 |
children | 4197fc428c7d |
rev | line source |
---|---|
5582 | 1 /* |
2 | |
17744
d63878346099
maint: Update copyright notices for release.
John W. Eaton <jwe@octave.org>
parents:
17336
diff
changeset
|
3 Copyright (C) 2005-2013 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" |
16940
99122191d3dd
maint: Rename regexp.h to lo-regexp.h, regexp.cc to lo-regexp.cc in liboctave.
Rik <rik@octave.org>
parents:
16919
diff
changeset
|
36 #include "lo-regexp.h" |
14024
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 |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14854
diff
changeset
|
39 #include "defun.h" |
14024
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 |
14543
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
47 // Replace backslash escapes in a string with the real values. We need |
15541
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
48 // two special functions instead of the one in utils.cc because the set |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
49 // of escape sequences used for regexp patterns and replacement strings |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
50 // is different from those used in the *printf functions. |
14543
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
51 |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
52 static std::string |
15541
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
53 do_regexp_ptn_string_escapes (const std::string& s) |
14543
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
54 { |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
55 std::string retval; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
56 |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
57 size_t i = 0; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
58 size_t j = 0; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
59 size_t len = s.length (); |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
60 |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
61 retval.resize (len); |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
62 |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
63 while (j < len) |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
64 { |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
65 if (s[j] == '\\' && j+1 < len) |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
66 { |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
67 switch (s[++j]) |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
68 { |
15541
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
69 case 'b': // backspace |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
70 retval[i] = '\b'; |
14543
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
71 break; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
72 |
16918
ab46b5c77669
Fix word boundary handling in regexp pattern (bug #38778)
Mike Miller <mtmiller@ieee.org>
parents:
16816
diff
changeset
|
73 // Translate \< and \> to PCRE word boundary |
ab46b5c77669
Fix word boundary handling in regexp pattern (bug #38778)
Mike Miller <mtmiller@ieee.org>
parents:
16816
diff
changeset
|
74 case '<': // begin word boundary |
ab46b5c77669
Fix word boundary handling in regexp pattern (bug #38778)
Mike Miller <mtmiller@ieee.org>
parents:
16816
diff
changeset
|
75 case '>': // end word boundary |
ab46b5c77669
Fix word boundary handling in regexp pattern (bug #38778)
Mike Miller <mtmiller@ieee.org>
parents:
16816
diff
changeset
|
76 retval[i] = '\\'; |
ab46b5c77669
Fix word boundary handling in regexp pattern (bug #38778)
Mike Miller <mtmiller@ieee.org>
parents:
16816
diff
changeset
|
77 retval[++i] = 'b'; |
ab46b5c77669
Fix word boundary handling in regexp pattern (bug #38778)
Mike Miller <mtmiller@ieee.org>
parents:
16816
diff
changeset
|
78 break; |
ab46b5c77669
Fix word boundary handling in regexp pattern (bug #38778)
Mike Miller <mtmiller@ieee.org>
parents:
16816
diff
changeset
|
79 |
15541
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
80 #if 0 |
17861
870f3e12e163
maint: Use phrase "FIXME:" for problem areas in code.
Rik <rik@octave.org>
parents:
17787
diff
changeset
|
81 // FIXME: To be complete, we need to handle \oN, \o{N}. |
870f3e12e163
maint: Use phrase "FIXME:" for problem areas in code.
Rik <rik@octave.org>
parents:
17787
diff
changeset
|
82 // The PCRE library already handles \N where N |
870f3e12e163
maint: Use phrase "FIXME:" for problem areas in code.
Rik <rik@octave.org>
parents:
17787
diff
changeset
|
83 // is an octal number. New code needs to merely |
870f3e12e163
maint: Use phrase "FIXME:" for problem areas in code.
Rik <rik@octave.org>
parents:
17787
diff
changeset
|
84 // replace \oN or \o{N} with \N. |
15541
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
85 case 'o': // octal number |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
86 #endif |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
87 |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
88 default: // pass escape sequence through |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
89 retval[i] = '\\'; |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
90 retval[++i] = s[j]; |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
91 break; |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
92 } |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
93 } |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
94 else |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
95 { |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
96 retval[i] = s[j]; |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
97 } |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
98 |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
99 i++; |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
100 j++; |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
101 } |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
102 |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
103 retval.resize (i); |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
104 |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
105 return retval; |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
106 } |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
107 |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
108 static std::string |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
109 do_regexp_rep_string_escapes (const std::string& s) |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
110 { |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
111 std::string retval; |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
112 |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
113 size_t i = 0; |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
114 size_t j = 0; |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
115 size_t len = s.length (); |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
116 |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
117 retval.resize (len); |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
118 |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
119 while (j < len) |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
120 { |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
121 if (s[j] == '\\' && j+1 < len) |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
122 { |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
123 switch (s[++j]) |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
124 { |
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
125 case 'a': // alarm |
14543
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
126 retval[i] = '\a'; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
127 break; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
128 |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
129 case 'b': // backspace |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
130 retval[i] = '\b'; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
131 break; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
132 |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
133 case 'f': // formfeed |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
134 retval[i] = '\f'; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
135 break; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
136 |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
137 case 'n': // newline |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
138 retval[i] = '\n'; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
139 break; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
140 |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
141 case 'r': // carriage return |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
142 retval[i] = '\r'; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
143 break; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
144 |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
145 case 't': // horizontal tab |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
146 retval[i] = '\t'; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
147 break; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
148 |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
149 case 'v': // vertical tab |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
150 retval[i] = '\v'; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
151 break; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
152 |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
153 #if 0 |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
154 // FIXME: to be complete, we need to handle \oN, \o{N}, \xN, and |
14543
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
155 // \x{N}. Hex digits may be upper or lower case. Brackets are |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
156 // optional, so \x5Bz is the same as \x{5B}z. |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
157 |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
158 case 'o': // octal number |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
159 case 'x': // hex number |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
160 #endif |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
161 |
15541
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
162 default: // pass escape sequence through |
14543
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
163 retval[i] = '\\'; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
164 retval[++i] = s[j]; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
165 break; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
166 } |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
167 } |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
168 else |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
169 { |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
170 retval[i] = s[j]; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
171 } |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
172 |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
173 i++; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
174 j++; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
175 } |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
176 |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
177 retval.resize (i); |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
178 |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
179 return retval; |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
180 } |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
181 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
182 static void |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
183 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
|
184 const std::string& who, int skip, bool& extra_args) |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
185 { |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
186 int nargin = args.length (); |
5582 | 187 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
188 extra_args = false; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
189 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
190 for (int i = skip; i < nargin; i++) |
5582 | 191 { |
19437
03067dab10ca
Use stricter input validation when looking for a string as input (bug #42651).
Rik <rik@octave.org>
parents:
17861
diff
changeset
|
192 std::string str; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
193 |
19437
03067dab10ca
Use stricter input validation when looking for a string as input (bug #42651).
Rik <rik@octave.org>
parents:
17861
diff
changeset
|
194 if (args(i).is_string ()) |
03067dab10ca
Use stricter input validation when looking for a string as input (bug #42651).
Rik <rik@octave.org>
parents:
17861
diff
changeset
|
195 str = args(i).string_value (); |
03067dab10ca
Use stricter input validation when looking for a string as input (bug #42651).
Rik <rik@octave.org>
parents:
17861
diff
changeset
|
196 else |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
197 { |
19437
03067dab10ca
Use stricter input validation when looking for a string as input (bug #42651).
Rik <rik@octave.org>
parents:
17861
diff
changeset
|
198 error ("%s: optional arguments must be strings", who.c_str ()); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
199 break; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
200 } |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
201 |
5582 | 202 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
|
203 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
204 if (str.find ("once", 0) == 0) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
205 options.once (true); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
206 else if (str.find ("matchcase", 0) == 0) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
207 options.case_insensitive (false); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
208 else if (str.find ("ignorecase", 0) == 0) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
209 options.case_insensitive (true); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
210 else if (str.find ("dotall", 0) == 0) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
211 options.dotexceptnewline (false); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
212 else if (str.find ("stringanchors", 0) == 0) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
213 options.lineanchors (false); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
214 else if (str.find ("literalspacing", 0) == 0) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
215 options.freespacing (false); |
14536
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
216 else if (str.find ("noemptymatch", 0) == 0) |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
217 options.emptymatch (false); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
218 else if (str.find ("dotexceptnewline", 0) == 0) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
219 options.dotexceptnewline (true); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
220 else if (str.find ("lineanchors", 0) == 0) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
221 options.lineanchors (true); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
222 else if (str.find ("freespacing", 0) == 0) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
223 options.freespacing (true); |
14536
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
224 else if (str.find ("emptymatch", 0) == 0) |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
225 options.emptymatch (true); |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
226 else if (str.find ("start", 0) == 0 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
227 || str.find ("end", 0) == 0 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
228 || str.find ("tokenextents", 0) == 0 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
229 || str.find ("match", 0) == 0 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
230 || str.find ("tokens", 0) == 0 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
231 || str.find ("names", 0) == 0 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
232 || str.find ("split", 0) == 0) |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
233 extra_args = true; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
234 else |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
235 error ("%s: unrecognized option", who.c_str ()); |
5582 | 236 } |
5785 | 237 } |
5582 | 238 |
5785 | 239 static octave_value_list |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
240 octregexp (const octave_value_list &args, int nargout, |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
241 const std::string &who, bool case_insensitive = false) |
5785 | 242 { |
243 octave_value_list retval; | |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
244 |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
245 int nargin = args.length (); |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
246 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
247 // Make sure we have string, pattern |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
248 const std::string buffer = args(0).string_value (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
249 if (error_state) |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
250 return retval; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
251 |
14543
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
252 std::string pattern = args(1).string_value (); |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
253 if (error_state) |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
254 return retval; |
14543
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
255 // Matlab compatibility. |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
256 if (args(1).is_sq_string ()) |
15541
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
257 pattern = do_regexp_ptn_string_escapes (pattern); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
258 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
259 regexp::opts options; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
260 options.case_insensitive (case_insensitive); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
261 bool extra_options = false; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
262 parse_options (options, args, who, 2, extra_options); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
263 if (error_state) |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
264 return retval; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
265 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
266 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
|
267 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
268 string_vector named_pats = rx_lst.named_patterns (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
269 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
270 size_t sz = rx_lst.size (); |
5785 | 271 |
272 if (! error_state) | |
273 { | |
274 // Converted the linked list in the correct form for the return values | |
275 | |
276 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
|
277 octave_scalar_map nmap; |
12464
dfeea9cae79e
require PCRE to build Octave
John W. Eaton <jwe@octave.org>
parents:
12462
diff
changeset
|
278 |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
279 retval.resize (7); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
280 |
5785 | 281 if (sz == 1) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
282 { |
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14543
diff
changeset
|
283 string_vector named_tokens = rx_lst.begin ()->named_tokens (); |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
284 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
285 for (int j = 0; j < named_pats.length (); j++) |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
286 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
|
287 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
288 retval(5) = nmap; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
289 } |
5785 | 290 else |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
291 { |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
292 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
|
293 { |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
294 Cell tmp (dim_vector (1, sz)); |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
295 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
296 i = 0; |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
297 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
|
298 p != rx_lst.end (); p++) |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
299 { |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
300 string_vector named_tokens = p->named_tokens (); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
301 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
302 tmp(i++) = named_tokens(j); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
303 } |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
304 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
305 nmap.assign (named_pats(j), octave_value (tmp)); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
306 } |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
307 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
308 retval(5) = nmap; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
309 } |
5785 | 310 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
311 if (options.once ()) |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
312 { |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
313 regexp::match_data::const_iterator p = rx_lst.begin (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
314 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
315 retval(4) = sz ? p->tokens () : Cell (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
316 retval(3) = sz ? p->match_string () : std::string (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
317 retval(2) = sz ? p->token_extents () : Matrix (); |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
318 |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
319 if (sz) |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
320 { |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
321 double start = p->start (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
322 double end = p->end (); |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
323 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
324 Cell split (dim_vector (1, 2)); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
325 split(0) = buffer.substr (0, start-1); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
326 split(1) = buffer.substr (end); |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
327 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
328 retval(6) = split; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
329 retval(1) = end; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
330 retval(0) = start; |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
331 } |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
332 else |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
333 { |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
334 retval(6) = buffer; |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
335 retval(1) = Matrix (); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
336 retval(0) = Matrix (); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
337 } |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
338 } |
7893
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
339 else |
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
340 { |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
341 Cell tokens (dim_vector (1, sz)); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
342 Cell match_string (dim_vector (1, sz)); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
343 Cell token_extents (dim_vector (1, sz)); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
344 NDArray end (dim_vector (1, sz)); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
345 NDArray start (dim_vector (1, sz)); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
346 Cell split (dim_vector (1, sz+1)); |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
347 size_t sp_start = 0; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
348 |
7893
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
349 i = 0; |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
350 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
|
351 p != rx_lst.end (); p++) |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
352 { |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
353 double s = p->start (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
354 double e = p->end (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
355 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
356 string_vector tmp = p->tokens (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
357 tokens(i) = Cell (dim_vector (1, tmp.length ()), tmp); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
358 match_string(i) = p->match_string (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
359 token_extents(i) = p->token_extents (); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
360 end(i) = e; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
361 start(i) = s; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
362 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
|
363 sp_start = e; |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
364 i++; |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
365 } |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
366 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
367 split(i) = buffer.substr (sp_start); |
5785 | 368 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
369 retval(6) = split; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
370 retval(4) = tokens; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
371 retval(3) = match_string; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
372 retval(2) = token_extents; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
373 retval(1) = end; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
374 retval(0) = start; |
7893
eb9ccb44ea41
make regexp(...,'once') matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7520
diff
changeset
|
375 } |
5582 | 376 |
377 // Alter the order of the output arguments | |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
378 |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
379 if (extra_options) |
10154
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 int n = 0; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
382 octave_value_list new_retval; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
383 new_retval.resize (nargout); |
5582 | 384 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
385 OCTAVE_LOCAL_BUFFER (int, arg_used, 6); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
386 for (int j = 0; j < 6; j++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
387 arg_used[j] = false; |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11572
diff
changeset
|
388 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
389 for (int j = 2; j < nargin; j++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
390 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
391 int k = 0; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
392 std::string str = args(j).string_value (); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
393 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
|
394 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
395 if (str.find ("once", 0) == 0 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
396 || str.find ("stringanchors", 0) == 0 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
397 || str.find ("lineanchors", 0) == 0 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
398 || str.find ("matchcase", 0) == 0 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
399 || str.find ("ignorecase", 0) == 0 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
400 || str.find ("dotall", 0) == 0 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
401 || str.find ("dotexceptnewline", 0) == 0 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
402 || str.find ("literalspacing", 0) == 0 |
14536
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
403 || str.find ("freespacing", 0) == 0 |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
404 || str.find ("noemptymatch", 0) == 0 |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
405 || str.find ("emptymatch", 0) == 0) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
406 continue; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
407 else if (str.find ("start", 0) == 0) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
408 k = 0; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
409 else if (str.find ("end", 0) == 0) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
410 k = 1; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
411 else if (str.find ("tokenextents", 0) == 0) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
412 k = 2; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
413 else if (str.find ("match", 0) == 0) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
414 k = 3; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
415 else if (str.find ("tokens", 0) == 0) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
416 k = 4; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
417 else if (str.find ("names", 0) == 0) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
418 k = 5; |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
419 else if (str.find ("split", 0) == 0) |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
420 k = 6; |
5582 | 421 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
422 new_retval(n++) = retval(k); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
423 arg_used[k] = true; |
5582 | 424 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
425 if (n == nargout) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
426 break; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
427 } |
5582 | 428 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
429 // Fill in the rest of the arguments |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
430 if (n < nargout) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
431 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
432 for (int j = 0; j < 6; j++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
433 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
434 if (! arg_used[j]) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
435 new_retval(n++) = retval(j); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
436 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
437 } |
5582 | 438 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
439 retval = new_retval; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
440 } |
5582 | 441 } |
442 | |
443 return retval; | |
444 } | |
445 | |
6361 | 446 static octave_value_list |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
447 octcellregexp (const octave_value_list &args, int nargout, |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
448 const std::string &who, bool case_insensitive = false) |
6361 | 449 { |
450 octave_value_list retval; | |
451 | |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
452 if (args(0).is_cell ()) |
6361 | 453 { |
454 OCTAVE_LOCAL_BUFFER (Cell, newretval, nargout); | |
455 octave_value_list new_args = args; | |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
456 Cell cellstr = args(0).cell_value (); |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
457 if (args(1).is_cell ()) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
458 { |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
459 Cell cellpat = args(1).cell_value (); |
6361 | 460 |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
461 if (cellpat.numel () == 1) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
462 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
463 for (int j = 0; j < nargout; j++) |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
464 newretval[j].resize (cellstr.dims ()); |
6361 | 465 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
466 new_args(1) = cellpat(0); |
6361 | 467 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
468 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
|
469 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
470 new_args(0) = cellstr(i); |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
471 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
|
472 case_insensitive); |
6361 | 473 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
474 if (error_state) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
475 break; |
6361 | 476 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
477 for (int j = 0; j < nargout; j++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
478 newretval[j](i) = tmp(j); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
479 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
480 } |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
481 else if (cellstr.numel () == 1) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
482 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
483 for (int j = 0; j < nargout; j++) |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
484 newretval[j].resize (cellpat.dims ()); |
6361 | 485 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
486 new_args(0) = cellstr(0); |
6361 | 487 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
488 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
|
489 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
490 new_args(1) = cellpat(i); |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
491 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
|
492 case_insensitive); |
6361 | 493 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
494 if (error_state) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
495 break; |
6361 | 496 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
497 for (int j = 0; j < nargout; j++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
498 newretval[j](i) = tmp(j); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
499 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
500 } |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
501 else if (cellstr.numel () == cellpat.numel ()) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
502 { |
6361 | 503 |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
504 if (cellstr.dims () != cellpat.dims ()) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
505 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
|
506 else |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
507 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
508 for (int j = 0; j < nargout; j++) |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
509 newretval[j].resize (cellstr.dims ()); |
6361 | 510 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
511 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
|
512 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
513 new_args(0) = cellstr(i); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
514 new_args(1) = cellpat(i); |
6361 | 515 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
516 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
|
517 case_insensitive); |
6361 | 518 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
519 if (error_state) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
520 break; |
6361 | 521 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
522 for (int j = 0; j < nargout; j++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
523 newretval[j](i) = tmp(j); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
524 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
525 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
526 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
527 else |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
528 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
|
529 } |
6361 | 530 else |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
531 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
532 for (int j = 0; j < nargout; j++) |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
533 newretval[j].resize (cellstr.dims ()); |
6361 | 534 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
535 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
|
536 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
537 new_args(0) = cellstr(i); |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
538 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
|
539 case_insensitive); |
6361 | 540 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
541 if (error_state) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
542 break; |
6361 | 543 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
544 for (int j = 0; j < nargout; j++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
545 newretval[j](i) = tmp(j); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
546 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
547 } |
6361 | 548 |
549 if (!error_state) | |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
550 for (int j = 0; j < nargout; j++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
551 retval(j) = octave_value (newretval[j]); |
6361 | 552 } |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
553 else if (args(1).is_cell ()) |
6361 | 554 { |
555 OCTAVE_LOCAL_BUFFER (Cell, newretval, nargout); | |
556 octave_value_list new_args = args; | |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
557 Cell cellpat = args(1).cell_value (); |
6361 | 558 |
559 for (int j = 0; j < nargout; j++) | |
14854
5ae9f0f77635
maint: Use Octave coding conventions for coddling parenthis is DLD-FUNCTIONS directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
560 newretval[j].resize (cellpat.dims ()); |
6361 | 561 |
562 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
|
563 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
564 new_args(1) = cellpat(i); |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
565 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
|
566 case_insensitive); |
6361 | 567 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
568 if (error_state) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
569 break; |
6361 | 570 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
571 for (int j = 0; j < nargout; j++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
572 newretval[j](i) = tmp(j); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
573 } |
6361 | 574 |
575 if (!error_state) | |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
576 { |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
577 for (int j = 0; j < nargout; j++) |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
578 retval(j) = octave_value (newretval[j]); |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
579 } |
6361 | 580 } |
581 else | |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
582 retval = octregexp (args, nargout, who, case_insensitive); |
6361 | 583 |
584 return retval; | |
585 | |
586 } | |
587 | |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14854
diff
changeset
|
588 DEFUN (regexp, args, nargout, |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
589 "-*- texinfo -*-\n\ |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14854
diff
changeset
|
590 @deftypefn {Built-in Function} {[@var{s}, @var{e}, @var{te}, @var{m}, @var{t}, @var{nm}, @var{sp}] =} regexp (@var{str}, @var{pat})\n\ |
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14854
diff
changeset
|
591 @deftypefnx {Built-in Function} {[@dots{}] =} regexp (@var{str}, @var{pat}, \"@var{opt1}\", @dots{})\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
592 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
|
593 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
|
594 are none.\n\ |
5582 | 595 \n\ |
596 The matched pattern @var{pat} can include any of the standard regex\n\ | |
597 operators, including:\n\ | |
598 \n\ | |
599 @table @code\n\ | |
600 @item .\n\ | |
601 Match any character\n\ | |
10840 | 602 \n\ |
5582 | 603 @item * + ? @{@}\n\ |
604 Repetition operators, representing\n\ | |
14366
b76f0740940e
doc: Periodic grammar check of documentation.
Rik <octave@nomad.inbox5.com>
parents:
14360
diff
changeset
|
605 \n\ |
5582 | 606 @table @code\n\ |
607 @item *\n\ | |
608 Match zero or more times\n\ | |
10840 | 609 \n\ |
5582 | 610 @item +\n\ |
611 Match one or more times\n\ | |
10840 | 612 \n\ |
5582 | 613 @item ?\n\ |
614 Match zero or one times\n\ | |
10840 | 615 \n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
616 @item @{@var{n}@}\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
617 Match exactly @var{n} times\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
618 \n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
619 @item @{@var{n},@}\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
620 Match @var{n} or more times\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
621 \n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
622 @item @{@var{m},@var{n}@}\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
623 Match between @var{m} and @var{n} times\n\ |
5582 | 624 @end table\n\ |
10840 | 625 \n\ |
5582 | 626 @item [@dots{}] [^@dots{}]\n\ |
10840 | 627 \n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
628 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
|
629 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
|
630 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
|
631 \n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
632 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
|
633 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
|
634 @code{[-+.\\d]+}.\n\ |
10840 | 635 \n\ |
14536
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
636 @item () (?:)\n\ |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
637 Grouping operator. The first form, parentheses only, also creates a token.\n\ |
10840 | 638 \n\ |
5582 | 639 @item |\n\ |
9036
58604c45ca74
Cleanup of data types related documentation
Rik <rdrider0-list@yahoo.com>
parents:
8920
diff
changeset
|
640 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
|
641 alternatives must be delimited by the grouping operator @code{()} above.\n\ |
10840 | 642 \n\ |
5582 | 643 @item ^ $\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
644 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
|
645 end (@code{$}) of the string.\n\ |
5582 | 646 @end table\n\ |
647 \n\ | |
15173
8593bed236f1
doc: Document escape character processing within single quotes for regexp, warning, error.
Rik <rik@octave.org>
parents:
15039
diff
changeset
|
648 In addition, the following escaped characters have special meaning.\n\ |
5582 | 649 \n\ |
650 @table @code\n\ | |
16919
908b4956cbfd
doc: remove '\b' from list of special regexp sequences (bug #38778).
Rik <rik@octave.org>
parents:
16918
diff
changeset
|
651 \n\ |
908b4956cbfd
doc: remove '\b' from list of special regexp sequences (bug #38778).
Rik <rik@octave.org>
parents:
16918
diff
changeset
|
652 @item \\d\n\ |
908b4956cbfd
doc: remove '\b' from list of special regexp sequences (bug #38778).
Rik <rik@octave.org>
parents:
16918
diff
changeset
|
653 Match any digit\n\ |
10840 | 654 \n\ |
16919
908b4956cbfd
doc: remove '\b' from list of special regexp sequences (bug #38778).
Rik <rik@octave.org>
parents:
16918
diff
changeset
|
655 @item \\D\n\ |
908b4956cbfd
doc: remove '\b' from list of special regexp sequences (bug #38778).
Rik <rik@octave.org>
parents:
16918
diff
changeset
|
656 Match any non-digit\n\ |
908b4956cbfd
doc: remove '\b' from list of special regexp sequences (bug #38778).
Rik <rik@octave.org>
parents:
16918
diff
changeset
|
657 \n\ |
908b4956cbfd
doc: remove '\b' from list of special regexp sequences (bug #38778).
Rik <rik@octave.org>
parents:
16918
diff
changeset
|
658 @item \\s\n\ |
908b4956cbfd
doc: remove '\b' from list of special regexp sequences (bug #38778).
Rik <rik@octave.org>
parents:
16918
diff
changeset
|
659 Match any whitespace character\n\ |
908b4956cbfd
doc: remove '\b' from list of special regexp sequences (bug #38778).
Rik <rik@octave.org>
parents:
16918
diff
changeset
|
660 \n\ |
908b4956cbfd
doc: remove '\b' from list of special regexp sequences (bug #38778).
Rik <rik@octave.org>
parents:
16918
diff
changeset
|
661 @item \\S\n\ |
908b4956cbfd
doc: remove '\b' from list of special regexp sequences (bug #38778).
Rik <rik@octave.org>
parents:
16918
diff
changeset
|
662 Match any non-whitespace character\n\ |
10840 | 663 \n\ |
5582 | 664 @item \\w\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
665 Match any word character\n\ |
10840 | 666 \n\ |
5582 | 667 @item \\W\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
668 Match any non-word character\n\ |
10840 | 669 \n\ |
5582 | 670 @item \\<\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
671 Match the beginning of a word\n\ |
10840 | 672 \n\ |
5582 | 673 @item \\>\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
674 Match the end of a word\n\ |
10840 | 675 \n\ |
16919
908b4956cbfd
doc: remove '\b' from list of special regexp sequences (bug #38778).
Rik <rik@octave.org>
parents:
16918
diff
changeset
|
676 @item \\B\n\ |
908b4956cbfd
doc: remove '\b' from list of special regexp sequences (bug #38778).
Rik <rik@octave.org>
parents:
16918
diff
changeset
|
677 Match within a word\n\ |
5582 | 678 @end table\n\ |
679 \n\ | |
15173
8593bed236f1
doc: Document escape character processing within single quotes for regexp, warning, error.
Rik <rik@octave.org>
parents:
15039
diff
changeset
|
680 Implementation Note: For compatibility with @sc{matlab}, ordinary escape\n\ |
17281
bc924baa2c4e
doc: Add new @qcode macro for code samples which are quoted.
Rik <rik@octave.org>
parents:
17097
diff
changeset
|
681 sequences (e.g., @qcode{\"\\n\"} => newline) are processed in @var{pat}\n\ |
15173
8593bed236f1
doc: Document escape character processing within single quotes for regexp, warning, error.
Rik <rik@octave.org>
parents:
15039
diff
changeset
|
682 regardless of whether @var{pat} has been defined within single quotes. Use\n\ |
8593bed236f1
doc: Document escape character processing within single quotes for regexp, warning, error.
Rik <rik@octave.org>
parents:
15039
diff
changeset
|
683 a second backslash to stop interpolation of the escape sequence (e.g.,\n\ |
8593bed236f1
doc: Document escape character processing within single quotes for regexp, warning, error.
Rik <rik@octave.org>
parents:
15039
diff
changeset
|
684 \"\\\\n\") or use the @code{regexptranslate} function.\n\ |
8593bed236f1
doc: Document escape character processing within single quotes for regexp, warning, error.
Rik <rik@octave.org>
parents:
15039
diff
changeset
|
685 \n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
686 The outputs of @code{regexp} default to the order given below\n\ |
5582 | 687 \n\ |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
688 @table @var\n\ |
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
689 @item s\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
690 The start indices of each matching substring\n\ |
5582 | 691 \n\ |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
692 @item e\n\ |
5582 | 693 The end indices of each matching substring\n\ |
694 \n\ | |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
695 @item te\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
696 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
|
697 @var{pat}\n\ |
5582 | 698 \n\ |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
699 @item m\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
700 A cell array of the text of each match\n\ |
5582 | 701 \n\ |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
702 @item t\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
703 A cell array of the text of each token matched\n\ |
5582 | 704 \n\ |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
705 @item nm\n\ |
5582 | 706 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
|
707 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
|
708 @code{(?<name>@dots{})}.\n\ |
13929
9cae456085c2
Grammarcheck of documentation before 3.6.0 release.
Rik <octave@nomad.inbox5.com>
parents:
13759
diff
changeset
|
709 \n\ |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
710 @item sp\n\ |
14536
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
711 A cell array of the text not returned by match, i.e., what remains if you\n\ |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
712 split the string based on @var{pat}.\n\ |
5582 | 713 @end table\n\ |
714 \n\ | |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
715 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
|
716 selected by additional @var{opt} arguments. These are strings and the\n\ |
5582 | 717 correspondence between the output arguments and the optional argument\n\ |
718 are\n\ | |
719 \n\ | |
720 @multitable @columnfractions 0.2 0.3 0.3 0.2\n\ | |
17281
bc924baa2c4e
doc: Add new @qcode macro for code samples which are quoted.
Rik <rik@octave.org>
parents:
17097
diff
changeset
|
721 @item @tab @qcode{'start'} @tab @var{s} @tab\n\ |
bc924baa2c4e
doc: Add new @qcode macro for code samples which are quoted.
Rik <rik@octave.org>
parents:
17097
diff
changeset
|
722 @item @tab @qcode{'end'} @tab @var{e} @tab\n\ |
bc924baa2c4e
doc: Add new @qcode macro for code samples which are quoted.
Rik <rik@octave.org>
parents:
17097
diff
changeset
|
723 @item @tab @qcode{'tokenExtents'} @tab @var{te} @tab\n\ |
bc924baa2c4e
doc: Add new @qcode macro for code samples which are quoted.
Rik <rik@octave.org>
parents:
17097
diff
changeset
|
724 @item @tab @qcode{'match'} @tab @var{m} @tab\n\ |
bc924baa2c4e
doc: Add new @qcode macro for code samples which are quoted.
Rik <rik@octave.org>
parents:
17097
diff
changeset
|
725 @item @tab @qcode{'tokens'} @tab @var{t} @tab\n\ |
bc924baa2c4e
doc: Add new @qcode macro for code samples which are quoted.
Rik <rik@octave.org>
parents:
17097
diff
changeset
|
726 @item @tab @qcode{'names'} @tab @var{nm} @tab\n\ |
bc924baa2c4e
doc: Add new @qcode macro for code samples which are quoted.
Rik <rik@octave.org>
parents:
17097
diff
changeset
|
727 @item @tab @qcode{'split'} @tab @var{sp} @tab\n\ |
5582 | 728 @end multitable\n\ |
729 \n\ | |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
730 Additional arguments are summarized below.\n\ |
5779 | 731 \n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
732 @table @samp\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
733 @item once\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
734 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
|
735 \n\ |
5779 | 736 @item matchcase\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
737 Make the matching case sensitive. (default)\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
738 \n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
739 Alternatively, use (?-i) in the pattern.\n\ |
10840 | 740 \n\ |
5779 | 741 @item ignorecase\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
742 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
|
743 \n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
744 Alternatively, use (?i) in the pattern.\n\ |
10840 | 745 \n\ |
5779 | 746 @item stringanchors\n\ |
12642
f96b9b9f141b
doc: Periodic grammarcheck and spellcheck of documentation.
Rik <octave@nomad.inbox5.com>
parents:
12464
diff
changeset
|
747 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
|
748 (default)\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
749 \n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
750 Alternatively, use (?-m) in the pattern.\n\ |
10840 | 751 \n\ |
5779 | 752 @item lineanchors\n\ |
753 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
|
754 \n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
755 Alternatively, use (?m) in the pattern.\n\ |
10840 | 756 \n\ |
5779 | 757 @item dotall\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
758 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
|
759 (default)\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
760 \n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
761 Alternatively, use (?s) in the pattern.\n\ |
10840 | 762 \n\ |
5779 | 763 @item dotexceptnewline\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
764 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
|
765 \n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
766 Alternatively, use (?-s) in the pattern.\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
767 \n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
768 @item literalspacing\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
769 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
|
770 used in pattern matching. (default)\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
771 \n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
772 Alternatively, use (?-x) in the pattern.\n\ |
10840 | 773 \n\ |
5779 | 774 @item freespacing\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
775 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
|
776 the character @samp{#}.\n\ |
10840 | 777 \n\ |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
778 Alternatively, use (?x) in the pattern.\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
779 \n\ |
14536
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
780 @item noemptymatch\n\ |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
781 Zero-length matches are not returned. (default)\n\ |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
782 \n\ |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
783 @item emptymatch\n\ |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
784 Return zero-length matches.\n\ |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
785 \n\ |
17281
bc924baa2c4e
doc: Add new @qcode macro for code samples which are quoted.
Rik <rik@octave.org>
parents:
17097
diff
changeset
|
786 @code{regexp ('a', 'b*', 'emptymatch')} returns @code{[1 2]} because there\n\ |
bc924baa2c4e
doc: Add new @qcode macro for code samples which are quoted.
Rik <rik@octave.org>
parents:
17097
diff
changeset
|
787 are zero or more @qcode{'b'} characters at positions 1 and end-of-string.\n\ |
14536
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
788 \n\ |
5779 | 789 @end table\n\ |
11572
7d6d8c1e471f
Grammarcheck Texinfo for files in src directory.
Rik <octave@nomad.inbox5.com>
parents:
11553
diff
changeset
|
790 @seealso{regexpi, strfind, regexprep}\n\ |
5582 | 791 @end deftypefn") |
792 { | |
6361 | 793 octave_value_list retval; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
794 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
795 int nargin = args.length (); |
6361 | 796 |
797 if (nargin < 2) | |
798 print_usage (); | |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
799 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
|
800 retval = octcellregexp (args, (nargout > 0 ? nargout : 1), "regexp"); |
6361 | 801 else |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
802 retval = octregexp (args, nargout, "regexp"); |
6361 | 803 |
804 return retval; | |
5582 | 805 } |
806 | |
807 /* | |
8140
cdd05e46f6c9
Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents:
8093
diff
changeset
|
808 ## PCRE_ERROR_MATCHLIMIT test |
cdd05e46f6c9
Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents:
8093
diff
changeset
|
809 %!test |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
810 %! s = sprintf ('\t4\n0000\t-0.00\t-0.0000\t4\t-0.00\t-0.0000\t4\n0000\t-0.00\t-0.0000\t0\t-0.00\t-'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
811 %! ws = warning ("query"); |
8140
cdd05e46f6c9
Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents:
8093
diff
changeset
|
812 %! unwind_protect |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
813 %! warning ("off"); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
814 %! regexp (s, '(\s*-*\d+[.]*\d*\s*)+\n'); |
8140
cdd05e46f6c9
Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents:
8093
diff
changeset
|
815 %! unwind_protect_cleanup |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
816 %! warning (ws); |
8140
cdd05e46f6c9
Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents:
8093
diff
changeset
|
817 %! end_unwind_protect |
cdd05e46f6c9
Increase pcre's match_limit for difficult regexps
Thomas Weber <thomas.weber.mail@gmail.com>
parents:
8093
diff
changeset
|
818 |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
819 ## segfault test |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
820 %!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
|
821 ## Infinite loop test |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
822 %!assert (isempty (regexp ("abcde", ""))) |
5582 | 823 |
824 ## Check that anchoring of pattern works correctly | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
825 %!assert (regexp ('abcabc', '^abc'), 1) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
826 %!assert (regexp ('abcabc', 'abc$'), 4) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
827 %!assert (regexp ('abcabc', '^abc$'), zeros (1,0)) |
5582 | 828 |
829 %!test | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
830 %! [s, e, te, m, t] = regexp (' No Match ', 'f(.*)uck'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
831 %! assert (s, zeros (1,0)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
832 %! assert (e, zeros (1,0)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
833 %! assert (te, cell (1,0)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
834 %! assert (m, cell (1,0)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
835 %! assert (t, cell (1,0)); |
5582 | 836 |
837 %!test | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
838 %! [s, e, te, m, t] = regexp (' FiRetrUck ', 'f(.*)uck'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
839 %! assert (s, zeros (1,0)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
840 %! assert (e, zeros (1,0)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
841 %! assert (te, cell (1,0)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
842 %! assert (m, cell (1,0)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
843 %! assert (t, cell (1,0)); |
5582 | 844 |
845 %!test | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
846 %! [s, e, te, m, t] = regexp (' firetruck ', 'f(.*)uck'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
847 %! assert (s, 2); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
848 %! assert (e, 10); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
849 %! assert (te{1}, [3, 7]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
850 %! assert (m{1}, 'firetruck'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
851 %! assert (t{1}{1}, 'iretr'); |
5582 | 852 |
853 %!test | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
854 %! [s, e, te, m, t] = regexp ('short test string', '\w*r\w*'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
855 %! assert (s, [1, 12]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
856 %! assert (e, [5, 17]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
857 %! assert (size (te), [1, 2]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
858 %! assert (isempty (te{1})); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
859 %! assert (isempty (te{2})); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
860 %! assert (m{1}, 'short'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
861 %! assert (m{2}, 'string'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
862 %! assert (size (t), [1, 2]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
863 %! assert (isempty (t{1})); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
864 %! assert (isempty (t{2})); |
5582 | 865 |
866 %!test | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
867 %! [s, e, te, m, t] = regexp ('short test string', '\w*r\w*', 'once'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
868 %! assert (s, 1); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
869 %! assert (e, 5); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
870 %! assert (isempty (te)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
871 %! assert (m, 'short'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
872 %! assert (isempty (t)); |
5582 | 873 |
874 %!test | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
875 %! [m, te, e, s, t] = regexp ('short test string', '\w*r\w*', 'once', 'match', 'tokenExtents', 'end', 'start', 'tokens'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
876 %! assert (s, 1); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
877 %! assert (e, 5); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
878 %! assert (isempty (te)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
879 %! assert (m, 'short'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
880 %! assert (isempty (t)); |
5582 | 881 |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
882 %!test |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
883 %! [s, e, te, m, t, nm] = regexp ('short test string', '(?<word1>\w*t)\s*(?<word2>\w*t)'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
884 %! assert (s, 1); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
885 %! assert (e, 10); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
886 %! assert (size (te), [1, 1]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
887 %! assert (te{1}, [1,5; 7,10]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
888 %! assert (m{1}, 'short test'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
889 %! assert (size (t), [1, 1]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
890 %! assert (t{1}{1}, 'short'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
891 %! assert (t{1}{2}, 'test'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
892 %! assert (size (nm), [1, 1]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
893 %! assert (! isempty (fieldnames (nm))); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
894 %! assert (sort (fieldnames (nm)), {'word1';'word2'}); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
895 %! assert (nm.word1, 'short'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
896 %! assert (nm.word2, 'test'); |
5582 | 897 |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
898 %!test |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
899 %! [nm, m, te, e, s, t] = regexp ('short test string', '(?<word1>\w*t)\s*(?<word2>\w*t)', 'names', 'match', 'tokenExtents', 'end', 'start', 'tokens'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
900 %! assert (s, 1); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
901 %! assert (e, 10); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
902 %! assert (size (te), [1, 1]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
903 %! assert (te{1}, [1,5; 7,10]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
904 %! assert (m{1}, 'short test'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
905 %! assert (size (t), [1, 1]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
906 %! assert (t{1}{1}, 'short'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
907 %! assert (t{1}{2}, 'test'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
908 %! assert (size (nm), [1, 1]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
909 %! assert (!isempty (fieldnames (nm))); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
910 %! assert (sort (fieldnames (nm)), {'word1';'word2'}); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
911 %! assert (nm.word1, 'short'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
912 %! assert (nm.word2, 'test'); |
5619 | 913 |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
914 %!test |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
915 %! [t, nm] = regexp ("John Davis\nRogers, James", '(?<first>\w+)\s+(?<last>\w+)|(?<last>\w+),\s+(?<first>\w+)', 'tokens', 'names'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
916 %! assert (size (t), [1, 2]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
917 %! assert (t{1}{1}, 'John'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
918 %! assert (t{1}{2}, 'Davis'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
919 %! assert (t{2}{1}, 'Rogers'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
920 %! assert (t{2}{2}, 'James'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
921 %! assert (size (nm), [1, 1]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
922 %! assert (nm.first{1}, 'John'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
923 %! assert (nm.first{2}, 'James'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
924 %! assert (nm.last{1}, 'Davis'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
925 %! assert (nm.last{2}, 'Rogers'); |
5582 | 926 |
14452
721be41ea988
Stop segfault when using regular expressions with named capture buffers (bug #35683).
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
927 ## Tests for named tokens |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
928 %!test |
17336
b81b9d079515
Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents:
17281
diff
changeset
|
929 %! ## Parenthesis in named token (ie (int)) causes a problem |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
930 %! assert (regexp ('qwe int asd', ['(?<typestr>(int))'], 'names'), struct ('typestr', 'int')); |
10518
fcafe0e9bd58
Handle repeated matches in matches returned by pcre
David Bateman <dbateman@free.fr>
parents:
10504
diff
changeset
|
931 |
14452
721be41ea988
Stop segfault when using regular expressions with named capture buffers (bug #35683).
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
932 %!test |
721be41ea988
Stop segfault when using regular expressions with named capture buffers (bug #35683).
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
933 %! ## 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
|
934 %! str = "abcde"; |
721be41ea988
Stop segfault when using regular expressions with named capture buffers (bug #35683).
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
935 %! 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
|
936 %! 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
|
937 %! 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
|
938 %! 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
|
939 %! 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
|
940 |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
941 %!assert (regexp ("abc\nabc", '.'), [1:7]) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
942 %!assert (regexp ("abc\nabc", '.', 'dotall'), [1:7]) |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
943 %!test |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
944 %! assert (regexp ("abc\nabc", '(?s).'), [1:7]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
945 %! assert (regexp ("abc\nabc", '.', 'dotexceptnewline'), [1,2,3,5,6,7]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
946 %! assert (regexp ("abc\nabc", '(?-s).'), [1,2,3,5,6,7]); |
5779 | 947 |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
948 %!assert (regexp ("caseCaSe", 'case'), 1) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
949 %!assert (regexp ("caseCaSe", 'case', "matchcase"), 1) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
950 %!assert (regexp ("caseCaSe", 'case', "ignorecase"), [1,5]) |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
951 %!test |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
952 %! assert (regexp ("caseCaSe", '(?-i)case'), 1); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
953 %! assert (regexp ("caseCaSe", '(?i)case'), [1, 5]); |
5779 | 954 |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
955 %!assert (regexp ("abc\nabc", 'c$'), 7) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
956 %!assert (regexp ("abc\nabc", 'c$', "stringanchors"), 7) |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
957 %!test |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
958 %! assert (regexp ("abc\nabc", '(?-m)c$'), 7); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
959 %! assert (regexp ("abc\nabc", 'c$',"lineanchors"), [3, 7]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
960 %! assert (regexp ("abc\nabc", '(?m)c$'), [3,7]); |
5779 | 961 |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
962 %!assert (regexp ("this word", 's w'), 4) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
963 %!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
|
964 %!test |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
965 %! assert (regexp ("this word", '(?-x)s w', 'literalspacing'), 4); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
966 %! assert (regexp ("this word", 's w', 'freespacing'), zeros (1,0)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
967 %! assert (regexp ("this word", '(?x)s w'), zeros (1,0)); |
5779 | 968 |
14536
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
969 %!test |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
970 %! [s, e, te, m, t, nm, sp] = regexp ('OCTAVE', '[VOCT]*', 'noemptymatch'); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
971 %! assert (s, [1 5]); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
972 %! assert (e, [3 5]); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
973 %! assert (te, { zeros(0,2), zeros(0,2) }); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
974 %! assert (m, { "OCT", "V" }); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
975 %! assert (t, { cell(1,0), cell(1,0) }); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
976 %! assert (isempty (fieldnames (nm))); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
977 %! assert (sp, { "", "A", "E" }); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
978 |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
979 %!test |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
980 %! [s, e, te, m, t, nm, sp] = regexp ('OCTAVE', '([VOCT]*)', 'noemptymatch'); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
981 %! assert (s, [1 5]); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
982 %! assert (e, [3 5]); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
983 %! assert (te, { [1 3], [5 5] }); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
984 %! assert (m, { "OCT", "V" }); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
985 %! assert (t, { {"OCT"}, {"V"} }); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
986 %! assert (isempty (fieldnames (nm))); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
987 %! assert (sp, { "", "A", "E" }); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
988 |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
989 %!test |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
990 %! [s, e, te, m, t, nm, sp] = regexp ('OCTAVE', '[VOCT]*', 'emptymatch'); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
991 %! assert (s, [1 4 5 6 7]); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
992 %! assert (e, [3 3 5 5 6]); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
993 %! assert (te, repmat ({zeros(0,2)}, [1, 5])); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
994 %! assert (m, { "OCT", "", "V", "", "" }); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
995 %! assert (t, repmat({cell(1,0)}, [1, 5])); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
996 %! assert (isempty (fieldnames (nm))); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
997 %! assert (sp, { "", "", "A", "", "E", "" }); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
998 |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
999 %!test |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
1000 %! [s, e, te, m, t, nm, sp] = regexp ('OCTAVE', '([VOCT]*)', 'emptymatch'); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
1001 %! assert (s, [1 4 5 6 7]); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
1002 %! assert (e, [3 3 5 5 6]); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
1003 %! assert (te, { [1 3], [4 3], [5 5], [6 5], [7 6] }); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
1004 %! assert (m, { "OCT", "", "V", "", "" }); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
1005 %! assert (t, { {"OCT"}, {""}, {"V"}, {""}, {""} }); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
1006 %! assert (isempty (fieldnames (nm))); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
1007 %! assert (sp, { "", "", "A", "", "E", "" }); |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
1008 |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1009 %!error regexp ('string', 'tri', 'BadArg') |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1010 %!error regexp ('string') |
5582 | 1011 |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1012 %!assert (regexp ({'asdfg-dfd';'-dfd-dfd-';'qasfdfdaq'}, '-'), {6;[1,5,9];zeros(1,0)}) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1013 %!assert (regexp ({'asdfg-dfd';'-dfd-dfd-';'qasfdfdaq'}, {'-';'f';'q'}), {6;[3,7];[1,9]}) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1014 %!assert (regexp ('Strings', {'t','s'}), {2, 7}) |
6361 | 1015 |
8093
dcc31f473596
Treat PCRE lookbehind operators in a manner that is approximately correct
David Bateman <dbateman@free.fr>
parents:
8021
diff
changeset
|
1016 ## Test case for lookaround operators |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
1017 %!test |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1018 %! assert (regexp ('Iraq', 'q(?!u)'), 4); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1019 %! assert (regexp ('quit', 'q(?!u)'), zeros (1, 0)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1020 %! assert (regexp ('quit', 'q(?=u)' , 'match'), {'q'}); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1021 %! assert (regexp ("quit", 'q(?=u+)', 'match'), {'q'}); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1022 %! assert (regexp ("qit", 'q(?=u+)', 'match'), cell (1, 0)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1023 %! assert (regexp ("qit", 'q(?=u*)', 'match'), {'q'}); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1024 %! 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
|
1025 |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1026 ## Tests for split option. |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1027 %!shared str |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1028 %! str = "foo bar foo"; |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1029 %!test |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1030 %! [a, b] = regexp (str, "f..", "match", "split"); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1031 %! assert (a, {"foo", "foo"}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1032 %! assert (b, {"", " bar ", ""}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1033 %!test |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1034 %! [a, b] = regexp (str, "f..", "match", "split", "once"); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1035 %! assert (a, "foo"); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1036 %! assert (b, {"", " bar foo"}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1037 %!test |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1038 %! [a, b] = regexp (str, "fx.", "match", "split"); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1039 %! assert (a, cell (1, 0)); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1040 %! assert (b, {"foo bar foo"}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1041 %!test |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1042 %! [a, b] = regexp (str, "fx.", "match", "split", "once"); |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1043 %! assert (a, "");; |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1044 %! assert (b, "foo bar foo"); |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1045 |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1046 %!shared str |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1047 %! str = "foo bar"; |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1048 %!test |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1049 %! [a, b] = regexp (str, "f..", "match", "split"); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1050 %! assert (a, {"foo"}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1051 %! assert (b, {"", " bar"}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1052 %!test |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1053 %! [a, b] = regexp (str, "b..", "match", "split"); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1054 %! assert (a, {"bar"}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1055 %! assert (b, {"foo ", ""}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1056 %!test |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1057 %! [a, b] = regexp (str, "x", "match", "split"); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1058 %! assert (a, cell (1, 0)); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1059 %! assert (b, {"foo bar"}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1060 %!test |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1061 %! [a, b] = regexp (str, "[o]+", "match", "split"); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1062 %! assert (a, {"oo"}); |
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1063 %! assert (b, {"f", " bar"}); |
14543
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
1064 |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
1065 %!assert (regexp ("\n", '\n'), 1); |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
1066 %!assert (regexp ("\n", "\n"), 1); |
5582 | 1067 */ |
1068 | |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14854
diff
changeset
|
1069 DEFUN (regexpi, args, nargout, |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1070 "-*- texinfo -*-\n\ |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14854
diff
changeset
|
1071 @deftypefn {Built-in Function} {[@var{s}, @var{e}, @var{te}, @var{m}, @var{t}, @var{nm}, @var{sp}] =} regexpi (@var{str}, @var{pat})\n\ |
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14854
diff
changeset
|
1072 @deftypefnx {Built-in Function} {[@dots{}] =} regexpi (@var{str}, @var{pat}, \"@var{opt1}\", @dots{})\n\ |
5582 | 1073 \n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1074 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
|
1075 @var{str} and return the positions and substrings of any matches, or empty\n\ |
17097
e7a059a9a644
doc: Use XREF as anchor prefix in documentation for clearer results in Info viewer.
Rik <rik@octave.org>
parents:
16940
diff
changeset
|
1076 values if there are none. @xref{XREFregexp,,regexp}, for details on the\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1077 syntax of the search pattern.\n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1078 @seealso{regexp}\n\ |
5582 | 1079 @end deftypefn") |
1080 { | |
6361 | 1081 octave_value_list retval; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1082 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1083 int nargin = args.length (); |
6361 | 1084 |
1085 if (nargin < 2) | |
1086 print_usage (); | |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1087 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
|
1088 retval = octcellregexp (args, (nargout > 0 ? nargout : 1), "regexpi", true); |
6361 | 1089 else |
1090 retval = octregexp (args, nargout, "regexpi", true); | |
1091 | |
1092 return retval; | |
5582 | 1093 } |
1094 | |
1095 /* | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1096 ## segfault test |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1097 %!assert (regexpi ("abcde", "."), [1,2,3,4,5]) |
5582 | 1098 |
1099 ## Check that anchoring of pattern works correctly | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1100 %!assert (regexpi ('abcabc', '^ABC'), 1) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1101 %!assert (regexpi ('abcabc', 'ABC$'), 4) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1102 %!assert (regexpi ('abcabc', '^ABC$'), zeros (1,0)) |
5582 | 1103 |
1104 %!test | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1105 %! [s, e, te, m, t] = regexpi (' No Match ', 'f(.*)uck'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1106 %! assert (s, zeros (1,0)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1107 %! assert (e, zeros (1,0)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1108 %! assert (te, cell (1,0)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1109 %! assert (m, cell (1,0)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1110 %! assert (t, cell (1,0)); |
5582 | 1111 |
1112 %!test | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1113 %! [s, e, te, m, t] = regexpi (' FiRetrUck ', 'f(.*)uck'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1114 %! assert (s, 2); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1115 %! assert (e, 10); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1116 %! assert (te{1}, [3, 7]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1117 %! assert (m{1}, 'FiRetrUck'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1118 %! assert (t{1}{1}, 'iRetr'); |
5582 | 1119 |
1120 %!test | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1121 %! [s, e, te, m, t] = regexpi (' firetruck ', 'f(.*)uck'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1122 %! assert (s, 2); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1123 %! assert (e, 10); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1124 %! assert (te{1}, [3, 7]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1125 %! assert (m{1}, 'firetruck'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1126 %! assert (t{1}{1}, 'iretr'); |
5582 | 1127 |
1128 %!test | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1129 %! [s, e, te, m, t] = regexpi ('ShoRt Test String', '\w*r\w*'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1130 %! assert (s, [1, 12]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1131 %! assert (e, [5, 17]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1132 %! assert (size (te), [1, 2]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1133 %! assert (isempty (te{1})); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1134 %! assert (isempty (te{2})); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1135 %! assert (m{1}, 'ShoRt'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1136 %! assert (m{2}, 'String'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1137 %! assert (size (t), [1, 2]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1138 %! assert (isempty (t{1})); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1139 %! assert (isempty (t{2})); |
5582 | 1140 |
1141 %!test | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1142 %! [s, e, te, m, t] = regexpi ('ShoRt Test String', '\w*r\w*', 'once'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1143 %! assert (s, 1); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1144 %! assert (e, 5); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1145 %! assert (isempty (te)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1146 %! assert (m, 'ShoRt'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1147 %! assert (isempty (t)); |
5582 | 1148 |
1149 %!test | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1150 %! [m, te, e, s, t] = regexpi ('ShoRt Test String', '\w*r\w*', 'once', 'match', 'tokenExtents', 'end', 'start', 'tokens'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1151 %! assert (s, 1); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1152 %! assert (e, 5); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1153 %! assert (isempty (te)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1154 %! assert (m, 'ShoRt'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1155 %! assert (isempty (t)); |
5582 | 1156 |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
1157 %!test |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1158 %! [s, e, te, m, t, nm] = regexpi ('ShoRt Test String', '(?<word1>\w*t)\s*(?<word2>\w*t)'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1159 %! assert (s, 1); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1160 %! assert (e, 10); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1161 %! assert (size (te), [1, 1]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1162 %! assert (te{1}, [1,5; 7,10]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1163 %! assert (m{1}, 'ShoRt Test'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1164 %! assert (size (t), [1, 1]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1165 %! assert (t{1}{1}, 'ShoRt'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1166 %! assert (t{1}{2}, 'Test'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1167 %! assert (size (nm), [1, 1]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1168 %! assert (! isempty (fieldnames (nm))); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1169 %! assert (sort (fieldnames (nm)), {'word1';'word2'}); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1170 %! assert (nm.word1, 'ShoRt'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1171 %! assert (nm.word2, 'Test'); |
5582 | 1172 |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
1173 %!test |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1174 %! [nm, m, te, e, s, t] = regexpi ('ShoRt Test String', '(?<word1>\w*t)\s*(?<word2>\w*t)', 'names', 'match', 'tokenExtents', 'end', 'start', 'tokens'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1175 %! assert (s, 1); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1176 %! assert (e, 10); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1177 %! assert (size (te), [1, 1]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1178 %! assert (te{1}, [1,5; 7,10]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1179 %! assert (m{1}, 'ShoRt Test'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1180 %! assert (size (t), [1, 1]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1181 %! assert (t{1}{1}, 'ShoRt'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1182 %! assert (t{1}{2}, 'Test'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1183 %! assert (size (nm), [1, 1]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1184 %! assert (!isempty (fieldnames (nm))); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1185 %! assert (sort (fieldnames (nm)), {'word1';'word2'}); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1186 %! assert (nm.word1, 'ShoRt'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1187 %! assert (nm.word2, 'Test'); |
5582 | 1188 |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1189 %!assert (regexpi ("abc\nabc", '.'), [1:7]) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1190 %!assert (regexpi ("abc\nabc", '.', 'dotall'), [1:7]) |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
1191 %!test |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1192 %! assert (regexpi ("abc\nabc", '(?s).'), [1:7]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1193 %! assert (regexpi ("abc\nabc", '.', 'dotexceptnewline'), [1,2,3,5,6,7]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1194 %! assert (regexpi ("abc\nabc", '(?-s).'), [1,2,3,5,6,7]); |
5779 | 1195 |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1196 %!assert (regexpi ("caseCaSe", 'case'), [1, 5]) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1197 %!assert (regexpi ("caseCaSe", 'case', "matchcase"), 1) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1198 %!assert (regexpi ("caseCaSe", 'case', "ignorecase"), [1, 5]) |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
1199 %!test |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1200 %! assert (regexpi ("caseCaSe", '(?-i)case'), 1); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1201 %! assert (regexpi ("caseCaSe", '(?i)case'), [1, 5]); |
5779 | 1202 |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1203 %!assert (regexpi ("abc\nabc", 'C$'), 7) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1204 %!assert (regexpi ("abc\nabc", 'C$', "stringanchors"), 7) |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
1205 %!test |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1206 %! assert (regexpi ("abc\nabc", '(?-m)C$'), 7); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1207 %! assert (regexpi ("abc\nabc", 'C$', "lineanchors"), [3, 7]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1208 %! assert (regexpi ("abc\nabc", '(?m)C$'), [3, 7]); |
5779 | 1209 |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1210 %!assert (regexpi ("this word", 'S w'), 4) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1211 %!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
|
1212 %!test |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1213 %! assert (regexpi ("this word", '(?-x)S w', 'literalspacing'), 4); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1214 %! assert (regexpi ("this word", 'S w', 'freespacing'), zeros (1,0)); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1215 %! assert (regexpi ("this word", '(?x)S w'), zeros (1,0)); |
5582 | 1216 |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1217 %!error regexpi ('string', 'tri', 'BadArg') |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1218 %!error regexpi ('string') |
6361 | 1219 |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1220 %!assert (regexpi ({'asdfg-dfd';'-dfd-dfd-';'qasfdfdaq'}, '-'), {6;[1,5,9];zeros(1, 0)}) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1221 %!assert (regexpi ({'asdfg-dfd', '-dfd-dfd-', 'qasfdfdaq'}, '-'), {6, [1,5,9], zeros(1,0)}) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1222 %!assert (regexpi ({'asdfg-dfd';'-dfd-dfd-';'qasfdfdaq'}, {'-';'f';'q'}), {6;[3,7];[1,9]}) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1223 %!assert (regexpi ('Strings', {'t', 's'}), {2, [1, 7]}) |
14543
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
1224 |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
1225 %!assert (regexpi ("\n", '\n'), 1); |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
1226 %!assert (regexpi ("\n", "\n"), 1); |
5582 | 1227 */ |
1228 | |
6361 | 1229 static octave_value |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1230 octregexprep (const octave_value_list &args, const std::string &who) |
5785 | 1231 { |
6361 | 1232 octave_value retval; |
5785 | 1233 |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1234 int nargin = args.length (); |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1235 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1236 // Make sure we have string, pattern, replacement |
5785 | 1237 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
|
1238 if (error_state) |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1239 return retval; |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1240 |
14543
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
1241 std::string pattern = args(1).string_value (); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1242 if (error_state) |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1243 return retval; |
14543
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
1244 // Matlab compatibility. |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
1245 if (args(1).is_sq_string ()) |
15541
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
1246 pattern = do_regexp_ptn_string_escapes (pattern); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1247 |
14543
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
1248 std::string replacement = args(2).string_value (); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1249 if (error_state) |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1250 return retval; |
14543
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
1251 // Matlab compatibility. |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
1252 if (args(2).is_sq_string ()) |
15541
9db32cabeacf
Fix backslash handling in regexp pattern (Bug #37092)
Rik <rik@octave.org>
parents:
15195
diff
changeset
|
1253 replacement = do_regexp_rep_string_escapes (replacement); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11572
diff
changeset
|
1254 |
5785 | 1255 // Pack options excluding 'tokenize' and various output |
1256 // reordering strings into regexp arg list | |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1257 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
|
1258 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1259 int len = 0; |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11572
diff
changeset
|
1260 for (int i = 3; i < nargin; i++) |
5785 | 1261 { |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1262 const std::string opt = args(i).string_value (); |
5785 | 1263 if (opt != "tokenize" && opt != "start" && opt != "end" |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1264 && opt != "tokenextents" && opt != "match" && opt != "tokens" |
13310
583940a28bfd
handle "split" option for regexp
John W. Eaton <jwe@octave.org>
parents:
13227
diff
changeset
|
1265 && opt != "names" && opt != "split" && opt != "warnings") |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1266 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1267 regexpargs(len++) = args(i); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1268 } |
5785 | 1269 } |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1270 regexpargs.resize (len); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11572
diff
changeset
|
1271 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1272 regexp::opts options; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1273 bool extra_args = false; |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1274 parse_options (options, regexpargs, who, 0, extra_args); |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1275 if (error_state) |
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1276 return retval; |
5785 | 1277 |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1278 return regexp_replace (pattern, buffer, replacement, options, who); |
6361 | 1279 } |
1280 | |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14854
diff
changeset
|
1281 DEFUN (regexprep, args, , |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1282 "-*- texinfo -*-\n\ |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14854
diff
changeset
|
1283 @deftypefn {Built-in Function} {@var{outstr} =} regexprep (@var{string}, @var{pat}, @var{repstr})\n\ |
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14854
diff
changeset
|
1284 @deftypefnx {Built-in Function} {@var{outstr} =} regexprep (@var{string}, @var{pat}, @var{repstr}, \"@var{opt1}\", @dots{})\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1285 Replace occurrences of pattern @var{pat} in @var{string} with @var{repstr}.\n\ |
6361 | 1286 \n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1287 The pattern is a regular expression as documented for @code{regexp}.\n\ |
17097
e7a059a9a644
doc: Use XREF as anchor prefix in documentation for clearer results in Info viewer.
Rik <rik@octave.org>
parents:
16940
diff
changeset
|
1288 @xref{XREFregexp,,regexp}.\n\ |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1289 \n\ |
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1290 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
|
1291 for the ith set of parentheses in the match string. For example,\n\ |
10840 | 1292 \n\ |
6361 | 1293 @example\n\ |
14360
97883071e8e4
doc: Correct off-by-1 spacings in all .cc docstrings
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
1294 regexprep (\"Bill Dunn\", '(\\w+) (\\w+)', '$2, $1')\n\ |
6361 | 1295 @end example\n\ |
10840 | 1296 \n\ |
10846
a4f482e66b65
Grammarcheck more of the documentation.
Rik <octave@nomad.inbox5.com>
parents:
10840
diff
changeset
|
1297 @noindent\n\ |
6361 | 1298 returns \"Dunn, Bill\"\n\ |
1299 \n\ | |
11025
df2152514429
Update docstrings for regular expression functions
Rik <octave@nomad.inbox5.com>
parents:
11018
diff
changeset
|
1300 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
|
1301 \n\ |
6361 | 1302 @table @samp\n\ |
1303 \n\ | |
1304 @item once\n\ | |
7001 | 1305 Replace only the first occurrence of @var{pat} in the result.\n\ |
6361 | 1306 \n\ |
1307 @item warnings\n\ | |
1308 This option is present for compatibility but is ignored.\n\ | |
1309 \n\ | |
1310 @end table\n\ | |
15173
8593bed236f1
doc: Document escape character processing within single quotes for regexp, warning, error.
Rik <rik@octave.org>
parents:
15039
diff
changeset
|
1311 \n\ |
8593bed236f1
doc: Document escape character processing within single quotes for regexp, warning, error.
Rik <rik@octave.org>
parents:
15039
diff
changeset
|
1312 Implementation Note: For compatibility with @sc{matlab}, ordinary escape\n\ |
17281
bc924baa2c4e
doc: Add new @qcode macro for code samples which are quoted.
Rik <rik@octave.org>
parents:
17097
diff
changeset
|
1313 sequences (e.g., @qcode{\"\\n\"} => newline) are processed in both @var{pat}\n\ |
16816
12005245b645
doc: Periodic grammarcheck of documentation.
Rik <rik@octave.org>
parents:
16772
diff
changeset
|
1314 and @var{repstr} regardless of whether they were defined within single\n\ |
12005245b645
doc: Periodic grammarcheck of documentation.
Rik <rik@octave.org>
parents:
16772
diff
changeset
|
1315 quotes. Use a second backslash to stop interpolation of the escape sequence\n\ |
12005245b645
doc: Periodic grammarcheck of documentation.
Rik <rik@octave.org>
parents:
16772
diff
changeset
|
1316 (e.g., \"\\\\n\") or use the @code{regexptranslate} function.\n\ |
11572
7d6d8c1e471f
Grammarcheck Texinfo for files in src directory.
Rik <octave@nomad.inbox5.com>
parents:
11553
diff
changeset
|
1317 @seealso{regexp, regexpi, strrep}\n\ |
6361 | 1318 @end deftypefn") |
1319 { | |
1320 octave_value_list retval; | |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1321 int nargin = args.length (); |
6361 | 1322 |
1323 if (nargin < 3) | |
1324 { | |
1325 print_usage (); | |
1326 return retval; | |
1327 } | |
1328 | |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1329 if (args(0).is_cell () || args(1).is_cell () || args(2).is_cell ()) |
6361 | 1330 { |
1331 Cell str; | |
1332 Cell pat; | |
1333 Cell rep; | |
6495 | 1334 dim_vector dv0; |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1335 dim_vector dv1 (1, 1); |
6361 | 1336 |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1337 if (args(0).is_cell ()) |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1338 str = args(0).cell_value (); |
6361 | 1339 else |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1340 str = Cell (args(0)); |
6361 | 1341 |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1342 if (args(1).is_cell ()) |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1343 pat = args(1).cell_value (); |
6361 | 1344 else |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1345 pat = Cell (args(1)); |
6361 | 1346 |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1347 if (args(2).is_cell ()) |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1348 rep = args(2).cell_value (); |
6361 | 1349 else |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1350 rep = Cell (args(2)); |
6361 | 1351 |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1352 dv0 = str.dims (); |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1353 if (pat.numel () != 1) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1354 { |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1355 dv1 = pat.dims (); |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1356 if (rep.numel () != 1 && dv1 != rep.dims ()) |
14024
fc9f204faea0
refactor regexp (bug #34440)
John W. Eaton <jwe@octave.org>
parents:
13929
diff
changeset
|
1357 error ("regexprep: inconsistent cell array dimensions"); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1358 } |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1359 else if (rep.numel () != 1) |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1360 dv1 = rep.dims (); |
6361 | 1361 |
1362 if (!error_state) | |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1363 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1364 Cell ret (dv0); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1365 octave_value_list new_args = args; |
6361 | 1366 |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1367 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
|
1368 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1369 new_args(0) = str(i); |
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14543
diff
changeset
|
1370 if (pat.numel () == 1) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1371 new_args(1) = pat(0); |
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14543
diff
changeset
|
1372 if (rep.numel () == 1) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1373 new_args(2) = rep(0); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1374 |
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1375 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
|
1376 { |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1377 if (pat.numel () != 1) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1378 new_args(1) = pat(j); |
13227
9559417aa965
maint: regexp.cc style fixes
John W. Eaton <jwe@octave.org>
parents:
12642
diff
changeset
|
1379 if (rep.numel () != 1) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1380 new_args(2) = rep(j); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1381 new_args(0) = octregexprep (new_args, "regexprep"); |
6361 | 1382 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1383 if (error_state) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1384 break; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1385 } |
6361 | 1386 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1387 if (error_state) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1388 break; |
6495 | 1389 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1390 ret(i) = new_args(0); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1391 } |
6361 | 1392 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1393 if (!error_state) |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1394 retval = args(0).is_cell () ? octave_value (ret) |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1395 : octave_value (ret(0)); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
9064
diff
changeset
|
1396 } |
6361 | 1397 } |
1398 else | |
1399 retval = octregexprep (args, "regexprep"); | |
1400 | |
5785 | 1401 return retval; |
1402 } | |
1403 | |
1404 /* | |
1405 %!test # Replace with empty | |
1406 %! xml = '<!-- This is some XML --> <tag v="hello">some stuff<!-- sample tag--></tag>'; | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1407 %! t = regexprep (xml, '<[!?][^>]*>', ''); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1408 %! assert (t, ' <tag v="hello">some stuff</tag>'); |
5785 | 1409 |
1410 %!test # Replace with non-empty | |
1411 %! xml = '<!-- This is some XML --> <tag v="hello">some stuff<!-- sample tag--></tag>'; | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1412 %! t = regexprep (xml, '<[!?][^>]*>', '?'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1413 %! assert (t, '? <tag v="hello">some stuff?</tag>'); |
5785 | 1414 |
1415 %!test # Check that 'tokenize' is ignored | |
1416 %! xml = '<!-- This is some XML --> <tag v="hello">some stuff<!-- sample tag--></tag>'; | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1417 %! t = regexprep (xml, '<[!?][^>]*>', '', 'tokenize'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1418 %! assert (t, ' <tag v="hello">some stuff</tag>'); |
5785 | 1419 |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
1420 ## Test capture replacement |
12462
e4dbfe3019b1
Use PCRE regular expressions throughout Octave.
Rik <octave@nomad.inbox5.com>
parents:
12433
diff
changeset
|
1421 %!test |
7242 | 1422 %! data = "Bob Smith\nDavid Hollerith\nSam Jenkins"; |
1423 %! result = "Smith, Bob\nHollerith, David\nJenkins, Sam"; | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1424 %! t = regexprep (data, '(?m)^(\w+)\s+(\w+)$', '$2, $1'); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1425 %! assert (t, result); |
5785 | 1426 |
11032
c9b0a75b02e8
Make all regexp in Octave compatible with both POSIX and PCRE.
Rik <octave@nomad.inbox5.com>
parents:
11025
diff
changeset
|
1427 ## Return the original if no match |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1428 %!assert (regexprep ('hello', 'world', 'earth'), 'hello') |
5785 | 1429 |
14536
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
1430 ## Test emptymatch |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
1431 %!assert (regexprep ('World', '^', 'Hello '), 'World') |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
1432 %!assert (regexprep ('World', '^', 'Hello ', 'emptymatch'), 'Hello World') |
6d5c951ec520
Add 'emptymatch', 'noemptymatch' options to regular expressions.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
1433 |
5785 | 1434 ## Test a general replacement |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1435 %!assert (regexprep ("a[b]c{d}e-f=g", "[^A-Za-z0-9_]", "_"), "a_b_c_d_e_f_g") |
5785 | 1436 |
1437 ## Make sure it works at the beginning and end | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1438 %!assert (regexprep ("a[b]c{d}e-f=g", "a", "_"), "_[b]c{d}e-f=g") |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1439 %!assert (regexprep ("a[b]c{d}e-f=g", "g", "_"), "a[b]c{d}e-f=_") |
5785 | 1440 |
1441 ## Options | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1442 %!assert (regexprep ("a[b]c{d}e-f=g", "[^A-Za-z0-9_]", "_", "once"), "a_b]c{d}e-f=g") |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1443 %!assert (regexprep ("a[b]c{d}e-f=g", "[^A-Z0-9_]", "_", "ignorecase"), "a_b_c_d_e_f_g") |
5785 | 1444 |
1445 ## Option combinations | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1446 %!assert (regexprep ("a[b]c{d}e-f=g", "[^A-Z0-9_]", "_", "once", "ignorecase"), "a_b]c{d}e-f=g") |
5785 | 1447 |
1448 ## End conditions on replacement | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1449 %!assert (regexprep ("abc", "(b)", ".$1"), "a.bc"); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1450 %!assert (regexprep ("abc", "(b)", "$1"), "abc"); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1451 %!assert (regexprep ("abc", "(b)", "$1."), "ab.c"); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1452 %!assert (regexprep ("abc", "(b)", "$1.."), "ab..c"); |
5785 | 1453 |
6361 | 1454 ## Test cell array arguments |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1455 %!assert (regexprep ("abc", {"b","a"}, "?"), "??c") |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1456 %!assert (regexprep ({"abc","cba"}, "b", "?"), {"a?c","c?a"}) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1457 %!assert (regexprep ({"abc","cba"}, {"b","a"}, {"?","!"}), {"!?c","c?!"}) |
6361 | 1458 |
8093
dcc31f473596
Treat PCRE lookbehind operators in a manner that is approximately correct
David Bateman <dbateman@free.fr>
parents:
8021
diff
changeset
|
1459 # Nasty lookbehind expression |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14496
diff
changeset
|
1460 %!assert (regexprep ('x^(-1)+y(-1)+z(-1)=0', '(?<=[a-z]+)\(\-[1-9]*\)', '_minus1'),'x^(-1)+y_minus1+z_minus1=0') |
14543
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
1461 |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
1462 %!assert (regexprep ("\n", '\n', "X"), "X"); |
e47d929fde8f
process backslash string escapes in regexp pattern and regexprep replacement (bug #35911)
John W. Eaton <jwe@octave.org>
parents:
14536
diff
changeset
|
1463 %!assert (regexprep ("\n", "\n", "X"), "X"); |
5785 | 1464 */ |