octave-nkf: libinterp/corefcn/regexp.cc annotate

annotate libinterp/corefcn/regexp.cc @ 20590:1a0a433c8263

eliminate more simple uses of error_state * dirfns.cc, oct-map.cc, oct-stream.cc, regexp.cc, ov-base-mat.cc, ov-cell.cc, pt-idx.cc, pt-mat.cc: Eliminate simple uses of error_state.

author	John W. Eaton <jwe@octave.org>
date	Mon, 05 Oct 2015 21:13:12 -0400
parents	b6a59cc96bfa
children	fd0efcdb3718

rev	line source
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1 /*
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	2
19731 4197fc428c7d maint: Update copyright notices for 2015. John W. Eaton <jwe@octave.org> parents: 19437 diff changeset	3 Copyright (C) 2005-2015 David Bateman
11523 fd0a3ac60b0e update copyright notices John W. Eaton <jwe@octave.org> parents: 11045 diff changeset	4 Copyright (C) 2002-2005 Paul Kienzle
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7007 diff changeset	5
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7007 diff changeset	6 This file is part of Octave.
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	7
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	8 Octave is free software; you can redistribute it and/or modify it
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	9 under the terms of the GNU General Public License as published by the
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7007 diff changeset	10 Free Software Foundation; either version 3 of the License, or (at your
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7007 diff changeset	11 option) any later version.
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	12
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	13 Octave is distributed in the hope that it will be useful, but WITHOUT
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	16 for more details.
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	17
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	18 You should have received a copy of the GNU General Public License
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7007 diff changeset	19 along with Octave; see the file COPYING. If not, see
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7007 diff changeset	20 <http://www.gnu.org/licenses/>.
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	21
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	22 */
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	23
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	24 #ifdef HAVE_CONFIG_H
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	25 #include <config.h>
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	26 #endif
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	27
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	28 #include <list>
5765 7ba9ad1fec11 [project @ 2006-04-17 05:05:15 by jwe] jwe parents: 5760 diff changeset	29 #include <sstream>
7ba9ad1fec11 [project @ 2006-04-17 05:05:15 by jwe] jwe parents: 5760 diff changeset	30
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	31 #include <pcre.h>
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	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 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	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
20246 f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	80 case 'o': // octal input
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	81 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	82 bool bad_esc_seq = (j+1 >= len);
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	83
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	84 bool brace = false;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	85 if (! bad_esc_seq && s[++j] == '{')
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	86 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	87 brace = true;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	88 j++;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	89 }
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	90
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	91 int tmpi = 0;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	92 size_t k;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	93 for (k = j; k < std::min (j+3+brace, len); k++)
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	94 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	95 int digit = s[k] - '0';
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	96 if (digit < 0 \|\| digit > 7)
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	97 break;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	98 tmpi <<= 3;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	99 tmpi += digit;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	100 }
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	101 if (bad_esc_seq \|\| (brace && s[k++] != '}'))
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	102 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	103 bad_esc_seq = true;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	104 tmpi = 0;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	105 warning ("malformed octal escape sequence '\\o' --\
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	106 converting to '\\0'");
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	107 }
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	108 retval[i] = tmpi;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	109 j = k - 1;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	110 break;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	111 }
15541 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 default: // pass escape sequence through
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	114 retval[i] = '\\';
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	115 retval[++i] = s[j];
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	116 break;
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	117 }
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 else
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 retval[i] = s[j];
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
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	124 i++;
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	125 j++;
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	126 }
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	127
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	128 retval.resize (i);
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	129
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	130 return retval;
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	131 }
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	132
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	133 static std::string
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	134 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	135 {
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	136 std::string retval;
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	137
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	138 size_t i = 0;
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	139 size_t j = 0;
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	140 size_t len = s.length ();
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	141
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	142 retval.resize (len);
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	143
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	144 while (j < len)
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	145 {
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	146 if (s[j] == '\\' && j+1 < len)
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	147 {
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	148 switch (s[++j])
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	149 {
9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	150 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	151 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	152 break;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	153
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	154 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	155 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	156 break;
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 '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	159 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	160 break;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	161
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	162 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	163 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	164 break;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	165
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	166 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	167 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	168 break;
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 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	171 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	172 break;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	173
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	174 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	175 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	176 break;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	177
20246 f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	178 case 'o': // octal input
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	179 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	180 bool bad_esc_seq = (j+1 >= len);
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	181
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	182 bool brace = false;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	183 if (! bad_esc_seq && s[++j] == '{')
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	184 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	185 brace = true;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	186 j++;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	187 }
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	188
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	189 int tmpi = 0;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	190 size_t k;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	191 for (k = j; k < std::min (j+3+brace, len); k++)
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	192 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	193 int digit = s[k] - '0';
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	194 if (digit < 0 \|\| digit > 7)
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	195 break;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	196 tmpi <<= 3;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	197 tmpi += digit;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	198 }
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	199 if (bad_esc_seq \|\| (brace && s[k++] != '}'))
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	200 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	201 warning ("malformed octal escape sequence '\\o' --\
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	202 converting to '\\0'");
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	203 tmpi = 0;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	204 }
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	205 retval[i] = tmpi;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	206 j = k - 1;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	207 break;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	208 }
14543 e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	209
20246 f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	210 case 'x': // hex input
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	211 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	212 bool bad_esc_seq = (j+1 >= len);
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	213
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	214 bool brace = false;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	215 if (! bad_esc_seq && s[++j] == '{')
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	216 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	217 brace = true;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	218 j++;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	219 }
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	220
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	221 int tmpi = 0;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	222 size_t k;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	223 for (k = j; k < std::min (j+2+brace, len); k++)
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	224 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	225 if (! isxdigit (s[k]))
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	226 break;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	227
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	228 tmpi <<= 4;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	229 int digit = s[k];
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	230 if (digit >= 'a')
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	231 tmpi += digit - 'a' + 10;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	232 else if (digit >= 'A')
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	233 tmpi += digit - 'A' + 10;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	234 else
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	235 tmpi += digit - '0';
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	236 }
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	237 if (bad_esc_seq \|\| (brace && s[k++] != '}'))
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	238 {
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	239 warning ("malformed hex escape sequence '\\x' --\
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	240 converting to '\\0'");
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	241 tmpi = 0;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	242 }
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	243 retval[i] = tmpi;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	244 j = k - 1;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	245 break;
f2bc7d23295d Add special hex/octal escape sequence processing for regexp. Rik <rik@octave.org> parents: 20207 diff changeset	246 }
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	247
20325 b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	248 // Both dollar sign (for capture buffer) and backslash are
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	249 // passed through with their escape backslash. The processing
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	250 // for these must occur during the actual replacement operation
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	251 // in lo-regexp.cc.
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	252 case '$': // pass dollar sign through with escape
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	253 retval[i] = '\\'; retval[++i] = '$';
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	254 break;
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	255
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	256 case '\\': // pass backslash through with escape
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	257 retval[i] = '\\'; retval[++i] = '\\';
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	258 break;
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	259
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	260 default: // convert escaped character to unescaped char
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	261 retval[i] = s[j];
14543 e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	262 break;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	263 }
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	264 }
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	265 else
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	266 {
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	267 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	268 }
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	269
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	270 i++;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	271 j++;
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	272 }
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	273
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	274 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	275
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	276 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	277 }
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	278
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	279 static void
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	280 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	281 const std::string& who, int skip, bool& extra_args)
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	282 {
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	283 int nargin = args.length ();
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	284
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	285 extra_args = false;
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	286
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	287 for (int i = skip; i < nargin; i++)
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	288 {
19437 03067dab10ca Use stricter input validation when looking for a string as input (bug #42651). Rik <rik@octave.org> parents: 17861 diff changeset	289 std::string str;
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	290
19437 03067dab10ca Use stricter input validation when looking for a string as input (bug #42651). Rik <rik@octave.org> parents: 17861 diff changeset	291 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	292 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	293 else
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	294 {
19437 03067dab10ca Use stricter input validation when looking for a string as input (bug #42651). Rik <rik@octave.org> parents: 17861 diff changeset	295 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	296 break;
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	297 }
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	298
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	299 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	300
9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	301 if (str.find ("once", 0) == 0)
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	302 options.once (true);
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	303 else if (str.find ("matchcase", 0) == 0)
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	304 options.case_insensitive (false);
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	305 else if (str.find ("ignorecase", 0) == 0)
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	306 options.case_insensitive (true);
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	307 else if (str.find ("dotall", 0) == 0)
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	308 options.dotexceptnewline (false);
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	309 else if (str.find ("stringanchors", 0) == 0)
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	310 options.lineanchors (false);
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	311 else if (str.find ("literalspacing", 0) == 0)
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	312 options.freespacing (false);
14536 6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	313 else if (str.find ("noemptymatch", 0) == 0)
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	314 options.emptymatch (false);
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	315 else if (str.find ("dotexceptnewline", 0) == 0)
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	316 options.dotexceptnewline (true);
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	317 else if (str.find ("lineanchors", 0) == 0)
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	318 options.lineanchors (true);
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	319 else if (str.find ("freespacing", 0) == 0)
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	320 options.freespacing (true);
14536 6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	321 else if (str.find ("emptymatch", 0) == 0)
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	322 options.emptymatch (true);
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	323 else if (str.find ("start", 0) == 0
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	324 \|\| str.find ("end", 0) == 0
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	325 \|\| str.find ("tokenextents", 0) == 0
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	326 \|\| str.find ("match", 0) == 0
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	327 \|\| str.find ("tokens", 0) == 0
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	328 \|\| str.find ("names", 0) == 0
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	329 \|\| str.find ("split", 0) == 0)
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	330 extra_args = true;
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	331 else
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	332 error ("%s: unrecognized option", who.c_str ());
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	333 }
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	334 }
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	335
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	336 static octave_value_list
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	337 octregexp (const octave_value_list &args, int nargout,
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	338 const std::string &who, bool case_insensitive = false)
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	339 {
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	340 octave_value_list retval;
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	341
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	342 int nargin = args.length ();
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	343
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	344 // Make sure we have string, pattern
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	345 const std::string buffer = args(0).string_value ();
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	346
14543 e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	347 std::string pattern = args(1).string_value ();
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	348
14543 e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	349 // 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	350 if (args(1).is_sq_string ())
15541 9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	351 pattern = do_regexp_ptn_string_escapes (pattern);
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	352
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	353 regexp::opts options;
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	354 options.case_insensitive (case_insensitive);
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	355 bool extra_options = false;
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	356 parse_options (options, args, who, 2, extra_options);
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	357
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	358 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	359
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	360 string_vector named_pats = rx_lst.named_patterns ();
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	361
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	362 size_t sz = rx_lst.size ();
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	363
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	364 // Converted the linked list in the correct form for the return values
12464 dfeea9cae79e require PCRE to build Octave John W. Eaton <jwe@octave.org> parents: 12462 diff changeset	365
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	366 octave_idx_type i = 0;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	367 octave_scalar_map nmap;
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	368
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	369 retval.resize (7);
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	370
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	371 if (sz == 1)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	372 {
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	373 string_vector named_tokens = rx_lst.begin ()->named_tokens ();
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	374
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	375 for (int j = 0; j < named_pats.numel (); j++)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	376 nmap.assign (named_pats(j), named_tokens(j));
13310 583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	377
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	378 retval(5) = nmap;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	379 }
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	380 else
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	381 {
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	382 for (int j = 0; j < named_pats.numel (); j++)
7893 eb9ccb44ea41 make regexp(...,'once') matlab compatible Jaroslav Hajek <highegg@gmail.com> parents: 7520 diff changeset	383 {
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	384 Cell tmp (dim_vector (1, sz));
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	385
7893 eb9ccb44ea41 make regexp(...,'once') matlab compatible Jaroslav Hajek <highegg@gmail.com> parents: 7520 diff changeset	386 i = 0;
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	387 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	388 p != rx_lst.end (); p++)
13310 583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	389 {
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	390 string_vector named_tokens = p->named_tokens ();
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	391
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	392 tmp(i++) = named_tokens(j);
13310 583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	393 }
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	394
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	395 nmap.assign (named_pats(j), octave_value (tmp));
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	396 }
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	397
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	398 retval(5) = nmap;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	399 }
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	400
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	401 if (options.once ())
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	402 {
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	403 regexp::match_data::const_iterator p = rx_lst.begin ();
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	404
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	405 retval(4) = sz ? p->tokens () : Cell ();
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	406 retval(3) = sz ? p->match_string () : std::string ();
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	407 retval(2) = sz ? p->token_extents () : Matrix ();
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	408
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	409 if (sz)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	410 {
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	411 double start = p->start ();
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	412 double end = p->end ();
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	413
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	414 Cell split (dim_vector (1, 2));
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	415 split(0) = buffer.substr (0, start-1);
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	416 split(1) = buffer.substr (end);
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	417
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	418 retval(6) = split;
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	419 retval(1) = end;
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	420 retval(0) = start;
7893 eb9ccb44ea41 make regexp(...,'once') matlab compatible Jaroslav Hajek <highegg@gmail.com> parents: 7520 diff changeset	421 }
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	422 else
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	423 {
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	424 retval(6) = buffer;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	425 retval(1) = Matrix ();
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	426 retval(0) = Matrix ();
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	427 }
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	428 }
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	429 else
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	430 {
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	431 Cell tokens (dim_vector (1, sz));
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	432 Cell match_string (dim_vector (1, sz));
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	433 Cell token_extents (dim_vector (1, sz));
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	434 NDArray end (dim_vector (1, sz));
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	435 NDArray start (dim_vector (1, sz));
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	436 Cell split (dim_vector (1, sz+1));
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	437 size_t sp_start = 0;
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	438
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	439 i = 0;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	440 for (regexp::match_data::const_iterator p = rx_lst.begin ();
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	441 p != rx_lst.end (); p++)
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	442 {
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	443 double s = p->start ();
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	444 double e = p->end ();
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	445
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	446 string_vector tmp = p->tokens ();
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	447 tokens(i) = Cell (dim_vector (1, tmp.numel ()), tmp);
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	448 match_string(i) = p->match_string ();
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	449 token_extents(i) = p->token_extents ();
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	450 end(i) = e;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	451 start(i) = s;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	452 split(i) = buffer.substr (sp_start, s-sp_start-1);
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	453 sp_start = e;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	454 i++;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	455 }
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	456
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	457 split(i) = buffer.substr (sp_start);
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11572 diff changeset	458
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	459 retval(6) = split;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	460 retval(4) = tokens;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	461 retval(3) = match_string;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	462 retval(2) = token_extents;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	463 retval(1) = end;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	464 retval(0) = start;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	465 }
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	466
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	467 // Alter the order of the output arguments
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	468
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	469 if (extra_options)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	470 {
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	471 int n = 0;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	472 octave_value_list new_retval;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	473 new_retval.resize (nargout);
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	474
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	475 OCTAVE_LOCAL_BUFFER (int, arg_used, 6);
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	476 for (int j = 0; j < 6; j++)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	477 arg_used[j] = false;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	478
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	479 for (int j = 2; j < nargin; j++)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	480 {
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	481 int k = 0;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	482 std::string str = args(j).string_value ();
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	483 std::transform (str.begin (), str.end (), str.begin (), tolower);
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	484
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	485 if (str.find ("once", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	486 \|\| str.find ("stringanchors", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	487 \|\| str.find ("lineanchors", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	488 \|\| str.find ("matchcase", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	489 \|\| str.find ("ignorecase", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	490 \|\| str.find ("dotall", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	491 \|\| str.find ("dotexceptnewline", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	492 \|\| str.find ("literalspacing", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	493 \|\| str.find ("freespacing", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	494 \|\| str.find ("noemptymatch", 0) == 0
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	495 \|\| str.find ("emptymatch", 0) == 0)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	496 continue;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	497 else if (str.find ("start", 0) == 0)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	498 k = 0;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	499 else if (str.find ("end", 0) == 0)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	500 k = 1;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	501 else if (str.find ("tokenextents", 0) == 0)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	502 k = 2;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	503 else if (str.find ("match", 0) == 0)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	504 k = 3;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	505 else if (str.find ("tokens", 0) == 0)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	506 k = 4;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	507 else if (str.find ("names", 0) == 0)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	508 k = 5;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	509 else if (str.find ("split", 0) == 0)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	510 k = 6;
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	511
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	512 new_retval(n++) = retval(k);
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	513 arg_used[k] = true;
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	514
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	515 if (n == nargout)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	516 break;
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	517 }
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	518
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	519 // Fill in the rest of the arguments
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	520 if (n < nargout)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	521 {
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	522 for (int j = 0; j < 6; j++)
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	523 {
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	524 if (! arg_used[j])
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	525 new_retval(n++) = retval(j);
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	526 }
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	527 }
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	528
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	529 retval = new_retval;
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	530 }
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	531
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	532 return retval;
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	533 }
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	534
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	535 static octave_value_list
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	536 octcellregexp (const octave_value_list &args, int nargout,
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	537 const std::string &who, bool case_insensitive = false)
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	538 {
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	539 octave_value_list retval;
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	540
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	541 if (args(0).is_cell ())
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	542 {
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	543 OCTAVE_LOCAL_BUFFER (Cell, newretval, nargout);
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	544 octave_value_list new_args = args;
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	545 Cell cellstr = args(0).cell_value ();
9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	546 if (args(1).is_cell ())
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	547 {
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	548 Cell cellpat = args(1).cell_value ();
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	549
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	550 if (cellpat.numel () == 1)
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	551 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	552 for (int j = 0; j < nargout; j++)
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	553 newretval[j].resize (cellstr.dims ());
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	554
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	555 new_args(1) = cellpat(0);
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	556
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	557 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	558 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	559 new_args(0) = cellstr(i);
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	560 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	561 case_insensitive);
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	562
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	563 for (int j = 0; j < nargout; j++)
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	564 newretval[j](i) = tmp(j);
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	565 }
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	566 }
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	567 else if (cellstr.numel () == 1)
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	568 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	569 for (int j = 0; j < nargout; j++)
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	570 newretval[j].resize (cellpat.dims ());
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	571
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	572 new_args(0) = cellstr(0);
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	573
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	574 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	575 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	576 new_args(1) = cellpat(i);
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	577 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	578 case_insensitive);
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	579
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	580 for (int j = 0; j < nargout; j++)
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	581 newretval[j](i) = tmp(j);
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	582 }
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	583 }
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	584 else if (cellstr.numel () == cellpat.numel ())
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	585 {
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	586
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	587 if (cellstr.dims () != cellpat.dims ())
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	588 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	589 else
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	590 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	591 for (int j = 0; j < nargout; j++)
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	592 newretval[j].resize (cellstr.dims ());
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	593
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	594 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	595 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	596 new_args(0) = cellstr(i);
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	597 new_args(1) = cellpat(i);
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	598
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	599 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	600 case_insensitive);
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	601
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	602 for (int j = 0; j < nargout; j++)
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	603 newretval[j](i) = tmp(j);
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	604 }
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	605 }
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	606 }
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	607 else
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	608 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	609 }
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	610 else
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	611 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	612 for (int j = 0; j < nargout; j++)
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	613 newretval[j].resize (cellstr.dims ());
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	614
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	615 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	616 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	617 new_args(0) = cellstr(i);
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	618 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	619 case_insensitive);
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	620
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	621 for (int j = 0; j < nargout; j++)
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	622 newretval[j](i) = tmp(j);
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	623 }
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	624 }
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	625
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	626 for (int j = 0; j < nargout; j++)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	627 retval(j) = octave_value (newretval[j]);
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	628 }
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	629 else if (args(1).is_cell ())
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	630 {
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	631 OCTAVE_LOCAL_BUFFER (Cell, newretval, nargout);
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	632 octave_value_list new_args = args;
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	633 Cell cellpat = args(1).cell_value ();
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	634
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	635 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	636 newretval[j].resize (cellpat.dims ());
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	637
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	638 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	639 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	640 new_args(1) = cellpat(i);
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	641 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	642 case_insensitive);
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	643
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	644 for (int j = 0; j < nargout; j++)
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	645 newretval[j](i) = tmp(j);
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	646 }
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	647
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	648 for (int j = 0; j < nargout; j++)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	649 retval(j) = octave_value (newretval[j]);
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	650 }
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	651 else
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	652 retval = octregexp (args, nargout, who, case_insensitive);
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	653
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	654 return retval;
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	655
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	656 }
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	657
15039 e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory Rik <rik@octave.org> parents: 14854 diff changeset	658 DEFUN (regexp, args, nargout,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	659 "-- texinfo --\n\
15039 e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory Rik <rik@octave.org> parents: 14854 diff changeset	660 @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	661 @deftypefnx {Built-in Function} {[@dots{}] =} regexp (@var{str}, @var{pat}, \"@var{opt1}\", @dots{})\n\
20207 4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20136 diff changeset	662 Regular expression string matching.\n\
4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20136 diff changeset	663 \n\
4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20136 diff changeset	664 Search for @var{pat} in @var{str} and return the positions and substrings of\n\
4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20136 diff changeset	665 any matches, or empty values if there are none.\n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	666 \n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	667 The matched pattern @var{pat} can include any of the standard regex\n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	668 operators, including:\n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	669 \n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	670 @table @code\n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	671 @item .\n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	672 Match any character\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	673 \n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	674 @item * + ? @{@}\n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	675 Repetition operators, representing\n\
14366 b76f0740940e doc: Periodic grammar check of documentation. Rik <octave@nomad.inbox5.com> parents: 14360 diff changeset	676 \n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	677 @table @code\n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	678 @item *\n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	679 Match zero or more times\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	680 \n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	681 @item +\n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	682 Match one or more times\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	683 \n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	684 @item ?\n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	685 Match zero or one times\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	686 \n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	687 @item @{@var{n}@}\n\
df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	688 Match exactly @var{n} times\n\
df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	689 \n\
df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	690 @item @{@var{n},@}\n\
df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	691 Match @var{n} or more times\n\
df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	692 \n\
df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	693 @item @{@var{m},@var{n}@}\n\
df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	694 Match between @var{m} and @var{n} times\n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	695 @end table\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	696 \n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	697 @item [@dots{}] [^@dots{}]\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	698 \n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	699 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	700 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	701 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	702 \n\
20207 4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20136 diff changeset	703 Escape sequences defined below can also be used inside list operators. For\n\
4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20136 diff changeset	704 example, a template for a floating point number might be @code{[-+.\\d]+}.\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	705 \n\
14536 6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	706 @item () (?:)\n\
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	707 Grouping operator. The first form, parentheses only, also creates a token.\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	708 \n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	709 @item \|\n\
9036 58604c45ca74 Cleanup of data types related documentation Rik <rdrider0-list@yahoo.com> parents: 8920 diff changeset	710 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	711 alternatives must be delimited by the grouping operator @code{()} above.\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	712 \n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	713 @item ^ $\n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	714 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	715 end (@code{$}) of the string.\n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	716 @end table\n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	717 \n\
15173 8593bed236f1 doc: Document escape character processing within single quotes for regexp, warning, error. Rik <rik@octave.org> parents: 15039 diff changeset	718 In addition, the following escaped characters have special meaning.\n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	719 \n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	720 @table @code\n\
16919 908b4956cbfd doc: remove '\b' from list of special regexp sequences (bug #38778). Rik <rik@octave.org> parents: 16918 diff changeset	721 \n\
908b4956cbfd doc: remove '\b' from list of special regexp sequences (bug #38778). Rik <rik@octave.org> parents: 16918 diff changeset	722 @item \\d\n\
908b4956cbfd doc: remove '\b' from list of special regexp sequences (bug #38778). Rik <rik@octave.org> parents: 16918 diff changeset	723 Match any digit\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	724 \n\
16919 908b4956cbfd doc: remove '\b' from list of special regexp sequences (bug #38778). Rik <rik@octave.org> parents: 16918 diff changeset	725 @item \\D\n\
908b4956cbfd doc: remove '\b' from list of special regexp sequences (bug #38778). Rik <rik@octave.org> parents: 16918 diff changeset	726 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	727 \n\
908b4956cbfd doc: remove '\b' from list of special regexp sequences (bug #38778). Rik <rik@octave.org> parents: 16918 diff changeset	728 @item \\s\n\
908b4956cbfd doc: remove '\b' from list of special regexp sequences (bug #38778). Rik <rik@octave.org> parents: 16918 diff changeset	729 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	730 \n\
908b4956cbfd doc: remove '\b' from list of special regexp sequences (bug #38778). Rik <rik@octave.org> parents: 16918 diff changeset	731 @item \\S\n\
908b4956cbfd doc: remove '\b' from list of special regexp sequences (bug #38778). Rik <rik@octave.org> parents: 16918 diff changeset	732 Match any non-whitespace character\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	733 \n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	734 @item \\w\n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	735 Match any word character\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	736 \n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	737 @item \\W\n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	738 Match any non-word character\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	739 \n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	740 @item \\<\n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	741 Match the beginning of a word\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	742 \n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	743 @item \\>\n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	744 Match the end of a word\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	745 \n\
16919 908b4956cbfd doc: remove '\b' from list of special regexp sequences (bug #38778). Rik <rik@octave.org> parents: 16918 diff changeset	746 @item \\B\n\
908b4956cbfd doc: remove '\b' from list of special regexp sequences (bug #38778). Rik <rik@octave.org> parents: 16918 diff changeset	747 Match within a word\n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	748 @end table\n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	749 \n\
20076 dbf2418a46dd Document expansion of escape sequences in single quotes (bug #44745). Rik <rik@octave.org> parents: 19731 diff changeset	750 Implementation Note: For compatibility with @sc{matlab}, escape sequences\n\
20136 e51473fdb622 doc: Periodic grammarcheck of documentation. Rik <rik@octave.org> parents: 20076 diff changeset	751 in @var{pat} (e.g., @qcode{\"@xbackslashchar{}n\"} => newline) are expanded\n\
e51473fdb622 doc: Periodic grammarcheck of documentation. Rik <rik@octave.org> parents: 20076 diff changeset	752 even when @var{pat} has been defined with single quotes. To disable\n\
e51473fdb622 doc: Periodic grammarcheck of documentation. Rik <rik@octave.org> parents: 20076 diff changeset	753 expansion use a second backslash before the escape sequence (e.g.,\n\
e51473fdb622 doc: Periodic grammarcheck of documentation. Rik <rik@octave.org> parents: 20076 diff changeset	754 \"@xbackslashchar{}@xbackslashchar{}n\") or use the @code{regexptranslate}\n\
e51473fdb622 doc: Periodic grammarcheck of documentation. Rik <rik@octave.org> parents: 20076 diff changeset	755 function.\n\
15173 8593bed236f1 doc: Document escape character processing within single quotes for regexp, warning, error. Rik <rik@octave.org> parents: 15039 diff changeset	756 \n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	757 The outputs of @code{regexp} default to the order given below\n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	758 \n\
11032 c9b0a75b02e8 Make all regexp in Octave compatible with both POSIX and PCRE. Rik <octave@nomad.inbox5.com> parents: 11025 diff changeset	759 @table @var\n\
c9b0a75b02e8 Make all regexp in Octave compatible with both POSIX and PCRE. Rik <octave@nomad.inbox5.com> parents: 11025 diff changeset	760 @item s\n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	761 The start indices of each matching substring\n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	762 \n\
11032 c9b0a75b02e8 Make all regexp in Octave compatible with both POSIX and PCRE. Rik <octave@nomad.inbox5.com> parents: 11025 diff changeset	763 @item e\n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	764 The end indices of each matching substring\n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	765 \n\
11032 c9b0a75b02e8 Make all regexp in Octave compatible with both POSIX and PCRE. Rik <octave@nomad.inbox5.com> parents: 11025 diff changeset	766 @item te\n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	767 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	768 @var{pat}\n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	769 \n\
11032 c9b0a75b02e8 Make all regexp in Octave compatible with both POSIX and PCRE. Rik <octave@nomad.inbox5.com> parents: 11025 diff changeset	770 @item m\n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	771 A cell array of the text of each match\n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	772 \n\
11032 c9b0a75b02e8 Make all regexp in Octave compatible with both POSIX and PCRE. Rik <octave@nomad.inbox5.com> parents: 11025 diff changeset	773 @item t\n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	774 A cell array of the text of each token matched\n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	775 \n\
11032 c9b0a75b02e8 Make all regexp in Octave compatible with both POSIX and PCRE. Rik <octave@nomad.inbox5.com> parents: 11025 diff changeset	776 @item nm\n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	777 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	778 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	779 @code{(?<name>@dots{})}.\n\
13929 9cae456085c2 Grammarcheck of documentation before 3.6.0 release. Rik <octave@nomad.inbox5.com> parents: 13759 diff changeset	780 \n\
13310 583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	781 @item sp\n\
14536 6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	782 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	783 split the string based on @var{pat}.\n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	784 @end table\n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	785 \n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	786 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	787 selected by additional @var{opt} arguments. These are strings and the\n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	788 correspondence between the output arguments and the optional argument\n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	789 are\n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	790 \n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	791 @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	792 @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	793 @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	794 @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	795 @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	796 @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	797 @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	798 @item @tab @qcode{'split'} @tab @var{sp} @tab\n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	799 @end multitable\n\
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	800 \n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	801 Additional arguments are summarized below.\n\
5779 12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman] dbateman parents: 5775 diff changeset	802 \n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	803 @table @samp\n\
df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	804 @item once\n\
df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	805 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	806 \n\
5779 12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman] dbateman parents: 5775 diff changeset	807 @item matchcase\n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	808 Make the matching case sensitive. (default)\n\
df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	809 \n\
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	810 Alternatively, use (?-i) in the pattern.\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	811 \n\
5779 12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman] dbateman parents: 5775 diff changeset	812 @item ignorecase\n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	813 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	814 \n\
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	815 Alternatively, use (?i) in the pattern.\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	816 \n\
5779 12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman] dbateman parents: 5775 diff changeset	817 @item stringanchors\n\
12642 f96b9b9f141b doc: Periodic grammarcheck and spellcheck of documentation. Rik <octave@nomad.inbox5.com> parents: 12464 diff changeset	818 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	819 (default)\n\
df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	820 \n\
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	821 Alternatively, use (?-m) in the pattern.\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	822 \n\
5779 12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman] dbateman parents: 5775 diff changeset	823 @item lineanchors\n\
12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman] dbateman parents: 5775 diff changeset	824 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	825 \n\
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	826 Alternatively, use (?m) in the pattern.\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	827 \n\
5779 12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman] dbateman parents: 5775 diff changeset	828 @item dotall\n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	829 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	830 (default)\n\
df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	831 \n\
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	832 Alternatively, use (?s) in the pattern.\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	833 \n\
5779 12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman] dbateman parents: 5775 diff changeset	834 @item dotexceptnewline\n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	835 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	836 \n\
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	837 Alternatively, use (?-s) in the pattern.\n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	838 \n\
df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	839 @item literalspacing\n\
df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	840 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	841 used in pattern matching. (default)\n\
df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	842 \n\
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	843 Alternatively, use (?-x) in the pattern.\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	844 \n\
5779 12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman] dbateman parents: 5775 diff changeset	845 @item freespacing\n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	846 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	847 the character @samp{#}.\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	848 \n\
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	849 Alternatively, use (?x) in the pattern.\n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	850 \n\
14536 6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	851 @item noemptymatch\n\
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	852 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	853 \n\
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	854 @item emptymatch\n\
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	855 Return zero-length matches.\n\
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	856 \n\
17281 bc924baa2c4e doc: Add new @qcode macro for code samples which are quoted. Rik <rik@octave.org> parents: 17097 diff changeset	857 @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	858 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	859 \n\
5779 12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman] dbateman parents: 5775 diff changeset	860 @end table\n\
11572 7d6d8c1e471f Grammarcheck Texinfo for files in src directory. Rik <octave@nomad.inbox5.com> parents: 11553 diff changeset	861 @seealso{regexpi, strfind, regexprep}\n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	862 @end deftypefn")
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	863 {
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	864 octave_value_list retval;
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	865
9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	866 int nargin = args.length ();
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	867
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	868 if (nargin < 2)
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	869 print_usage ();
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	870 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	871 retval = octcellregexp (args, (nargout > 0 ? nargout : 1), "regexp");
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	872 else
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	873 retval = octregexp (args, nargout, "regexp");
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	874
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	875 return retval;
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	876 }
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	877
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	878 /*
8140 cdd05e46f6c9 Increase pcre's match_limit for difficult regexps Thomas Weber <thomas.weber.mail@gmail.com> parents: 8093 diff changeset	879 ## PCRE_ERROR_MATCHLIMIT test
cdd05e46f6c9 Increase pcre's match_limit for difficult regexps Thomas Weber <thomas.weber.mail@gmail.com> parents: 8093 diff changeset	880 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	881 %! 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	882 %! ws = warning ("query");
8140 cdd05e46f6c9 Increase pcre's match_limit for difficult regexps Thomas Weber <thomas.weber.mail@gmail.com> parents: 8093 diff changeset	883 %! unwind_protect
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	884 %! warning ("off");
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	885 %! 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	886 %! unwind_protect_cleanup
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	887 %! warning (ws);
8140 cdd05e46f6c9 Increase pcre's match_limit for difficult regexps Thomas Weber <thomas.weber.mail@gmail.com> parents: 8093 diff changeset	888 %! end_unwind_protect
cdd05e46f6c9 Increase pcre's match_limit for difficult regexps Thomas Weber <thomas.weber.mail@gmail.com> parents: 8093 diff changeset	889
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	890 ## segfault test
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	891 %!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	892 ## Infinite loop test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	893 %!assert (isempty (regexp ("abcde", "")))
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	894
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	895 ## 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	896 %!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	897 %!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	898 %!assert (regexp ('abcabc', '^abc$'), zeros (1,0))
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	899
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	900 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	901 %! [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	902 %! 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	903 %! 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	904 %! 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	905 %! 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	906 %! assert (t, cell (1,0));
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	907
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	908 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	909 %! [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	910 %! 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	911 %! 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	912 %! 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	913 %! 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	914 %! assert (t, cell (1,0));
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	915
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	916 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	917 %! [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	918 %! assert (s, 2);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	919 %! assert (e, 10);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	920 %! 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	921 %! assert (m{1}, 'firetruck');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	922 %! assert (t{1}{1}, 'iretr');
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	923
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	924 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	925 %! [s, e, te, m, t] = regexp ('short test string', '\wr\w');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	926 %! assert (s, [1, 12]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	927 %! assert (e, [5, 17]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	928 %! 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	929 %! assert (isempty (te{1}));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	930 %! assert (isempty (te{2}));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	931 %! assert (m{1}, 'short');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	932 %! assert (m{2}, 'string');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	933 %! 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	934 %! assert (isempty (t{1}));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	935 %! assert (isempty (t{2}));
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	936
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	937 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	938 %! [s, e, te, m, t] = regexp ('short test string', '\wr\w', 'once');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	939 %! assert (s, 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	940 %! assert (e, 5);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	941 %! assert (isempty (te));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	942 %! assert (m, 'short');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	943 %! assert (isempty (t));
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	944
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	945 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	946 %! [m, te, e, s, t] = regexp ('short test string', '\wr\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	947 %! assert (s, 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	948 %! assert (e, 5);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	949 %! assert (isempty (te));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	950 %! assert (m, 'short');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	951 %! assert (isempty (t));
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	952
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	953 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	954 %! [s, e, te, m, t, nm] = regexp ('short test string', '(?<word1>\wt)\s(?<word2>\w*t)');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	955 %! assert (s, 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	956 %! assert (e, 10);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	957 %! 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	958 %! 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	959 %! 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	960 %! 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	961 %! 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	962 %! 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	963 %! 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	964 %! assert (! isempty (fieldnames (nm)));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	965 %! 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	966 %! assert (nm.word1, 'short');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	967 %! assert (nm.word2, 'test');
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	968
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	969 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	970 %! [nm, m, te, e, s, t] = regexp ('short test string', '(?<word1>\wt)\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	971 %! assert (s, 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	972 %! assert (e, 10);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	973 %! 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	974 %! 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	975 %! 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	976 %! 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	977 %! 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	978 %! 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	979 %! 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	980 %! assert (!isempty (fieldnames (nm)));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	981 %! 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	982 %! assert (nm.word1, 'short');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	983 %! assert (nm.word2, 'test');
5619 e9112ff172b1 [project @ 2006-02-13 20:05:36 by dbateman] dbateman parents: 5582 diff changeset	984
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	985 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	986 %! [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	987 %! 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	988 %! 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	989 %! 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	990 %! 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	991 %! 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	992 %! 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	993 %! 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	994 %! 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	995 %! 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	996 %! assert (nm.last{2}, 'Rogers');
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	997
14452 721be41ea988 Stop segfault when using regular expressions with named capture buffers (bug #35683). Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	998 ## Tests for named tokens
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	999 %!test
17336 b81b9d079515 Use '##' for comments which stand alone on a line. Rik <rik@octave.org> parents: 17281 diff changeset	1000 %! ## 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	1001 %! 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	1002
14452 721be41ea988 Stop segfault when using regular expressions with named capture buffers (bug #35683). Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	1003 %!test
721be41ea988 Stop segfault when using regular expressions with named capture buffers (bug #35683). Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	1004 %! ## 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	1005 %! str = "abcde";
721be41ea988 Stop segfault when using regular expressions with named capture buffers (bug #35683). Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	1006 %! 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	1007 %! 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	1008 %! 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	1009 %! 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	1010 %! 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	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 ("abc\nabc", '.'), [1:7])
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1013 %!assert (regexp ("abc\nabc", '.', 'dotall'), [1:7])
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	1014 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1015 %! 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	1016 %! 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	1017 %! assert (regexp ("abc\nabc", '(?-s).'), [1,2,3,5,6,7]);
5779 12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman] dbateman parents: 5775 diff changeset	1018
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1019 %!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	1020 %!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	1021 %!assert (regexp ("caseCaSe", 'case', "ignorecase"), [1,5])
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	1022 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1023 %! 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	1024 %! assert (regexp ("caseCaSe", '(?i)case'), [1, 5]);
5779 12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman] dbateman parents: 5775 diff changeset	1025
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1026 %!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	1027 %!assert (regexp ("abc\nabc", 'c$', "stringanchors"), 7)
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	1028 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1029 %! 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	1030 %! 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	1031 %! assert (regexp ("abc\nabc", '(?m)c$'), [3,7]);
5779 12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman] dbateman parents: 5775 diff changeset	1032
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1033 %!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	1034 %!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	1035 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1036 %! 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	1037 %! 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	1038 %! assert (regexp ("this word", '(?x)s w'), zeros (1,0));
5779 12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman] dbateman parents: 5775 diff changeset	1039
14536 6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1040 %!test
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1041 %! [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	1042 %! assert (s, [1 5]);
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1043 %! assert (e, [3 5]);
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1044 %! 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	1045 %! assert (m, { "OCT", "V" });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1046 %! 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	1047 %! assert (isempty (fieldnames (nm)));
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1048 %! assert (sp, { "", "A", "E" });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1049
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1050 %!test
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1051 %! [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	1052 %! assert (s, [1 5]);
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1053 %! assert (e, [3 5]);
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1054 %! assert (te, { [1 3], [5 5] });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1055 %! assert (m, { "OCT", "V" });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1056 %! assert (t, { {"OCT"}, {"V"} });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1057 %! assert (isempty (fieldnames (nm)));
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1058 %! assert (sp, { "", "A", "E" });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1059
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1060 %!test
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1061 %! [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	1062 %! assert (s, [1 4 5 6 7]);
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1063 %! assert (e, [3 3 5 5 6]);
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1064 %! 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	1065 %! assert (m, { "OCT", "", "V", "", "" });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1066 %! 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	1067 %! assert (isempty (fieldnames (nm)));
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1068 %! assert (sp, { "", "", "A", "", "E", "" });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1069
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1070 %!test
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1071 %! [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	1072 %! assert (s, [1 4 5 6 7]);
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1073 %! assert (e, [3 3 5 5 6]);
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1074 %! 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	1075 %! assert (m, { "OCT", "", "V", "", "" });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1076 %! assert (t, { {"OCT"}, {""}, {"V"}, {""}, {""} });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1077 %! assert (isempty (fieldnames (nm)));
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1078 %! assert (sp, { "", "", "A", "", "E", "" });
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1079
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1080 %!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	1081 %!error regexp ('string')
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1082
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1083 %!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	1084 %!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	1085 %!assert (regexp ('Strings', {'t','s'}), {2, 7})
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1086
8093 dcc31f473596 Treat PCRE lookbehind operators in a manner that is approximately correct David Bateman <dbateman@free.fr> parents: 8021 diff changeset	1087 ## Test case for lookaround operators
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	1088 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1089 %! 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	1090 %! 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	1091 %! 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	1092 %! 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	1093 %! 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	1094 %! 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	1095 %! 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	1096
13310 583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1097 ## Tests for split option.
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1098 %!shared str
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1099 %! str = "foo bar foo";
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1100 %!test
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1101 %! [a, b] = regexp (str, "f..", "match", "split");
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1102 %! assert (a, {"foo", "foo"});
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1103 %! assert (b, {"", " bar ", ""});
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1104 %!test
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1105 %! [a, b] = regexp (str, "f..", "match", "split", "once");
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1106 %! assert (a, "foo");
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1107 %! assert (b, {"", " bar foo"});
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1108 %!test
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1109 %! [a, b] = regexp (str, "fx.", "match", "split");
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1110 %! assert (a, cell (1, 0));
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1111 %! assert (b, {"foo bar foo"});
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1112 %!test
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1113 %! [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	1114 %! assert (a, "");;
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1115 %! assert (b, "foo bar foo");
13310 583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1116
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1117 %!shared str
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1118 %! str = "foo bar";
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1119 %!test
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1120 %! [a, b] = regexp (str, "f..", "match", "split");
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1121 %! assert (a, {"foo"});
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1122 %! assert (b, {"", " bar"});
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1123 %!test
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1124 %! [a, b] = regexp (str, "b..", "match", "split");
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1125 %! assert (a, {"bar"});
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1126 %! assert (b, {"foo ", ""});
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1127 %!test
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1128 %! [a, b] = regexp (str, "x", "match", "split");
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1129 %! assert (a, cell (1, 0));
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1130 %! assert (b, {"foo bar"});
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1131 %!test
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1132 %! [a, b] = regexp (str, "[o]+", "match", "split");
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1133 %! assert (a, {"oo"});
583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1134 %! 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	1135
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	1136 %!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	1137 %!assert (regexp ("\n", "\n"), 1);
20325 b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	1138
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	1139 %!test # Bug #45407, escape sequences are silently converted
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	1140 %! assert (regexprep ('s', 's', 'x\.y'), 'x.y');
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	1141 %! assert (regexprep ('s', '(s)', 'x\$1y'), 'x$1y');
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	1142 %! assert (regexprep ('s', '(s)', 'x\\$1y'), 'x\sy');
b6a59cc96bfa Process backslashes in regexprep replacement strings in Matlab compatible fashion (bug #45407). Rik <rik@octave.org> parents: 20267 diff changeset	1143
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1144 */
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1145
15039 e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory Rik <rik@octave.org> parents: 14854 diff changeset	1146 DEFUN (regexpi, args, nargout,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1147 "-- texinfo --\n\
15039 e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory Rik <rik@octave.org> parents: 14854 diff changeset	1148 @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	1149 @deftypefnx {Built-in Function} {[@dots{}] =} regexpi (@var{str}, @var{pat}, \"@var{opt1}\", @dots{})\n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1150 \n\
20207 4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20136 diff changeset	1151 Case insensitive regular expression string matching.\n\
4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20136 diff changeset	1152 \n\
4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20136 diff changeset	1153 Search for @var{pat} in @var{str} and return the positions and substrings of\n\
4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20136 diff changeset	1154 any matches, or empty values if there are none. @xref{XREFregexp,,regexp},\n\
4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20136 diff changeset	1155 for details on the syntax of the search pattern.\n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	1156 @seealso{regexp}\n\
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1157 @end deftypefn")
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1158 {
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1159 octave_value_list retval;
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1160
9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1161 int nargin = args.length ();
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1162
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1163 if (nargin < 2)
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1164 print_usage ();
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1165 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	1166 retval = octcellregexp (args, (nargout > 0 ? nargout : 1), "regexpi", true);
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1167 else
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1168 retval = octregexp (args, nargout, "regexpi", true);
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1169
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1170 return retval;
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1171 }
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1172
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1173 /*
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1174 ## segfault test
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1175 %!assert (regexpi ("abcde", "."), [1,2,3,4,5])
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1176
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1177 ## 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	1178 %!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	1179 %!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	1180 %!assert (regexpi ('abcabc', '^ABC$'), zeros (1,0))
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1181
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1182 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1183 %! [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	1184 %! 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	1185 %! 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	1186 %! 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	1187 %! 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	1188 %! assert (t, cell (1,0));
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1189
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1190 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1191 %! [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	1192 %! assert (s, 2);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1193 %! assert (e, 10);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1194 %! 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	1195 %! assert (m{1}, 'FiRetrUck');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1196 %! assert (t{1}{1}, 'iRetr');
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1197
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1198 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1199 %! [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	1200 %! assert (s, 2);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1201 %! assert (e, 10);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1202 %! 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	1203 %! assert (m{1}, 'firetruck');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1204 %! assert (t{1}{1}, 'iretr');
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1205
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1206 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1207 %! [s, e, te, m, t] = regexpi ('ShoRt Test String', '\wr\w');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1208 %! assert (s, [1, 12]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1209 %! assert (e, [5, 17]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1210 %! 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	1211 %! assert (isempty (te{1}));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1212 %! assert (isempty (te{2}));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1213 %! assert (m{1}, 'ShoRt');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1214 %! assert (m{2}, 'String');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1215 %! 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	1216 %! assert (isempty (t{1}));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1217 %! assert (isempty (t{2}));
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1218
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1219 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1220 %! [s, e, te, m, t] = regexpi ('ShoRt Test String', '\wr\w', 'once');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1221 %! assert (s, 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1222 %! assert (e, 5);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1223 %! assert (isempty (te));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1224 %! assert (m, 'ShoRt');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1225 %! assert (isempty (t));
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1226
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1227 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1228 %! [m, te, e, s, t] = regexpi ('ShoRt Test String', '\wr\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	1229 %! assert (s, 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1230 %! assert (e, 5);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1231 %! assert (isempty (te));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1232 %! assert (m, 'ShoRt');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1233 %! assert (isempty (t));
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1234
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	1235 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1236 %! [s, e, te, m, t, nm] = regexpi ('ShoRt Test String', '(?<word1>\wt)\s(?<word2>\w*t)');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1237 %! assert (s, 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1238 %! assert (e, 10);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1239 %! 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	1240 %! 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	1241 %! 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	1242 %! 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	1243 %! 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	1244 %! 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	1245 %! 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	1246 %! assert (! isempty (fieldnames (nm)));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1247 %! 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	1248 %! assert (nm.word1, 'ShoRt');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1249 %! assert (nm.word2, 'Test');
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1250
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	1251 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1252 %! [nm, m, te, e, s, t] = regexpi ('ShoRt Test String', '(?<word1>\wt)\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	1253 %! assert (s, 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1254 %! assert (e, 10);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1255 %! 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	1256 %! 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	1257 %! 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	1258 %! 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	1259 %! 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	1260 %! 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	1261 %! 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	1262 %! assert (!isempty (fieldnames (nm)));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1263 %! 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	1264 %! assert (nm.word1, 'ShoRt');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1265 %! assert (nm.word2, 'Test');
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1266
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1267 %!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	1268 %!assert (regexpi ("abc\nabc", '.', 'dotall'), [1:7])
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	1269 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1270 %! 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	1271 %! 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	1272 %! assert (regexpi ("abc\nabc", '(?-s).'), [1,2,3,5,6,7]);
5779 12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman] dbateman parents: 5775 diff changeset	1273
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1274 %!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	1275 %!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	1276 %!assert (regexpi ("caseCaSe", 'case', "ignorecase"), [1, 5])
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	1277 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1278 %! 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	1279 %! assert (regexpi ("caseCaSe", '(?i)case'), [1, 5]);
5779 12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman] dbateman parents: 5775 diff changeset	1280
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1281 %!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	1282 %!assert (regexpi ("abc\nabc", 'C$', "stringanchors"), 7)
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	1283 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1284 %! 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	1285 %! 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	1286 %! assert (regexpi ("abc\nabc", '(?m)C$'), [3, 7]);
5779 12eeebfa7ead [project @ 2006-04-27 19:30:14 by dbateman] dbateman parents: 5775 diff changeset	1287
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1288 %!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	1289 %!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	1290 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1291 %! 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	1292 %! 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	1293 %! assert (regexpi ("this word", '(?x)S w'), zeros (1,0));
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1294
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1295 %!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	1296 %!error regexpi ('string')
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1297
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1298 %!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	1299 %!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	1300 %!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	1301 %!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	1302
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	1303 %!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	1304 %!assert (regexpi ("\n", "\n"), 1);
5582 6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1305 */
6bf56668b01a [project @ 2005-12-15 01:08:20 by jwe] jwe parents: diff changeset	1306
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1307 static octave_value
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	1308 octregexprep (const octave_value_list &args, const std::string &who)
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1309 {
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1310 octave_value retval;
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1311
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1312 int nargin = args.length ();
9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1313
9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1314 // Make sure we have string, pattern, replacement
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1315 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	1316
14543 e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	1317 std::string pattern = args(1).string_value ();
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1318
14543 e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	1319 // 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	1320 if (args(1).is_sq_string ())
15541 9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	1321 pattern = do_regexp_ptn_string_escapes (pattern);
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1322
14543 e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	1323 std::string replacement = args(2).string_value ();
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1324
14543 e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	1325 // 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	1326 if (args(2).is_sq_string ())
15541 9db32cabeacf Fix backslash handling in regexp pattern (Bug #37092) Rik <rik@octave.org> parents: 15195 diff changeset	1327 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	1328
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1329 // Pack options excluding 'tokenize' and various output
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1330 // reordering strings into regexp arg list
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	1331 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	1332
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	1333 int len = 0;
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11572 diff changeset	1334 for (int i = 3; i < nargin; i++)
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1335 {
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1336 const std::string opt = args(i).string_value ();
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1337 if (opt != "tokenize" && opt != "start" && opt != "end"
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	1338 && opt != "tokenextents" && opt != "match" && opt != "tokens"
13310 583940a28bfd handle "split" option for regexp John W. Eaton <jwe@octave.org> parents: 13227 diff changeset	1339 && opt != "names" && opt != "split" && opt != "warnings")
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	1340 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	1341 regexpargs(len++) = args(i);
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	1342 }
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1343 }
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1344 regexpargs.resize (len);
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11572 diff changeset	1345
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	1346 regexp::opts options;
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	1347 bool extra_args = false;
fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	1348 parse_options (options, regexpargs, who, 0, extra_args);
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1349
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	1350 return regexp_replace (pattern, buffer, replacement, options, who);
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1351 }
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1352
15039 e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory Rik <rik@octave.org> parents: 14854 diff changeset	1353 DEFUN (regexprep, args, ,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1354 "-- texinfo --\n\
15039 e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory Rik <rik@octave.org> parents: 14854 diff changeset	1355 @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	1356 @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	1357 Replace occurrences of pattern @var{pat} in @var{string} with @var{repstr}.\n\
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1358 \n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	1359 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	1360 @xref{XREFregexp,,regexp}.\n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	1361 \n\
20207 4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20136 diff changeset	1362 The replacement string may contain @code{$i}, which substitutes for the ith\n\
4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20136 diff changeset	1363 set of parentheses in the match string. For example,\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	1364 \n\
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1365 @example\n\
14360 97883071e8e4 doc: Correct off-by-1 spacings in all .cc docstrings Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	1366 regexprep (\"Bill Dunn\", '(\\w+) (\\w+)', '$2, $1')\n\
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1367 @end example\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10551 diff changeset	1368 \n\
10846 a4f482e66b65 Grammarcheck more of the documentation. Rik <octave@nomad.inbox5.com> parents: 10840 diff changeset	1369 @noindent\n\
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1370 returns \"Dunn, Bill\"\n\
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1371 \n\
11025 df2152514429 Update docstrings for regular expression functions Rik <octave@nomad.inbox5.com> parents: 11018 diff changeset	1372 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	1373 \n\
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1374 @table @samp\n\
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1375 \n\
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1376 @item once\n\
7001 8b0cfeb06365 [project @ 2007-10-10 18:02:59 by jwe] jwe parents: 6678 diff changeset	1377 Replace only the first occurrence of @var{pat} in the result.\n\
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1378 \n\
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1379 @item warnings\n\
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1380 This option is present for compatibility but is ignored.\n\
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1381 \n\
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1382 @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	1383 \n\
20076 dbf2418a46dd Document expansion of escape sequences in single quotes (bug #44745). Rik <rik@octave.org> parents: 19731 diff changeset	1384 Implementation Note: For compatibility with @sc{matlab}, escape sequences\n\
20136 e51473fdb622 doc: Periodic grammarcheck of documentation. Rik <rik@octave.org> parents: 20076 diff changeset	1385 in @var{pat} (e.g., @qcode{\"@xbackslashchar{}n\"} => newline) are expanded\n\
e51473fdb622 doc: Periodic grammarcheck of documentation. Rik <rik@octave.org> parents: 20076 diff changeset	1386 even when @var{pat} has been defined with single quotes. To disable\n\
e51473fdb622 doc: Periodic grammarcheck of documentation. Rik <rik@octave.org> parents: 20076 diff changeset	1387 expansion use a second backslash before the escape sequence (e.g.,\n\
e51473fdb622 doc: Periodic grammarcheck of documentation. Rik <rik@octave.org> parents: 20076 diff changeset	1388 \"@xbackslashchar{}@xbackslashchar{}n\") or use the @code{regexptranslate}\n\
e51473fdb622 doc: Periodic grammarcheck of documentation. Rik <rik@octave.org> parents: 20076 diff changeset	1389 function.\n\
11572 7d6d8c1e471f Grammarcheck Texinfo for files in src directory. Rik <octave@nomad.inbox5.com> parents: 11553 diff changeset	1390 @seealso{regexp, regexpi, strrep}\n\
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1391 @end deftypefn")
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1392 {
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1393 octave_value_list retval;
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1394 int nargin = args.length ();
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1395
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1396 if (nargin < 3)
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1397 {
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1398 print_usage ();
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1399 return retval;
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1400 }
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1401
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1402 if (args(0).is_cell () \|\| args(1).is_cell () \|\| args(2).is_cell ())
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1403 {
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1404 Cell str;
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1405 Cell pat;
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1406 Cell rep;
6495 fd09c7e8c4c9 [project @ 2007-04-05 16:18:20 by dbateman] dbateman parents: 6361 diff changeset	1407 dim_vector dv0;
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1408 dim_vector dv1 (1, 1);
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1409
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1410 if (args(0).is_cell ())
9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1411 str = args(0).cell_value ();
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1412 else
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	1413 str = Cell (args(0));
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1414
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1415 if (args(1).is_cell ())
9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1416 pat = args(1).cell_value ();
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1417 else
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	1418 pat = Cell (args(1));
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1419
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1420 if (args(2).is_cell ())
9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1421 rep = args(2).cell_value ();
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1422 else
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	1423 rep = Cell (args(2));
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1424
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1425 dv0 = str.dims ();
9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1426 if (pat.numel () != 1)
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	1427 {
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1428 dv1 = pat.dims ();
9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1429 if (rep.numel () != 1 && dv1 != rep.dims ())
14024 fc9f204faea0 refactor regexp (bug #34440) John W. Eaton <jwe@octave.org> parents: 13929 diff changeset	1430 error ("regexprep: inconsistent cell array dimensions");
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	1431 }
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1432 else if (rep.numel () != 1)
9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1433 dv1 = rep.dims ();
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1434
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1435 Cell ret (dv0);
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1436 octave_value_list new_args = args;
13227 9559417aa965 maint: regexp.cc style fixes John W. Eaton <jwe@octave.org> parents: 12642 diff changeset	1437
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1438 for (octave_idx_type i = 0; i < dv0.numel (); i++)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1439 {
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1440 new_args(0) = str(i);
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1441 if (pat.numel () == 1)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1442 new_args(1) = pat(0);
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1443 if (rep.numel () == 1)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1444 new_args(2) = rep(0);
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1445
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1446 for (octave_idx_type j = 0; j < dv1.numel (); j++)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1447 {
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1448 if (pat.numel () != 1)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1449 new_args(1) = pat(j);
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1450 if (rep.numel () != 1)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1451 new_args(2) = rep(j);
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1452 new_args(0) = octregexprep (new_args, "regexprep");
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	1453 }
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1454
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1455 ret(i) = new_args(0);
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9064 diff changeset	1456 }
20590 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1457
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1458 retval = args(0).is_cell () ? octave_value (ret)
1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20325 diff changeset	1459 : octave_value (ret(0));
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1460 }
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1461 else
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1462 retval = octregexprep (args, "regexprep");
776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1463
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1464 return retval;
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1465 }
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1466
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1467 /*
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1468 %!test # Replace with empty
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1469 %! 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	1470 %! t = regexprep (xml, '<[!?][^>]*>', '');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1471 %! assert (t, ' <tag v="hello">some stuff</tag>');
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1472
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1473 %!test # Replace with non-empty
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1474 %! 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	1475 %! t = regexprep (xml, '<[!?][^>]*>', '?');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1476 %! assert (t, '? <tag v="hello">some stuff?</tag>');
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1477
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1478 %!test # Check that 'tokenize' is ignored
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1479 %! 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	1480 %! t = regexprep (xml, '<[!?][^>]*>', '', 'tokenize');
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1481 %! assert (t, ' <tag v="hello">some stuff</tag>');
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1482
11032 c9b0a75b02e8 Make all regexp in Octave compatible with both POSIX and PCRE. Rik <octave@nomad.inbox5.com> parents: 11025 diff changeset	1483 ## Test capture replacement
12462 e4dbfe3019b1 Use PCRE regular expressions throughout Octave. Rik <octave@nomad.inbox5.com> parents: 12433 diff changeset	1484 %!test
7242 e4398e3903be [project @ 2007-12-03 23:52:07 by dbateman] dbateman parents: 7237 diff changeset	1485 %! data = "Bob Smith\nDavid Hollerith\nSam Jenkins";
e4398e3903be [project @ 2007-12-03 23:52:07 by dbateman] dbateman parents: 7237 diff changeset	1486 %! 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	1487 %! 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	1488 %! assert (t, result);
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1489
11032 c9b0a75b02e8 Make all regexp in Octave compatible with both POSIX and PCRE. Rik <octave@nomad.inbox5.com> parents: 11025 diff changeset	1490 ## 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	1491 %!assert (regexprep ('hello', 'world', 'earth'), 'hello')
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1492
14536 6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1493 ## Test emptymatch
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1494 %!assert (regexprep ('World', '^', 'Hello '), 'World')
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1495 %!assert (regexprep ('World', '^', 'Hello ', 'emptymatch'), 'Hello World')
6d5c951ec520 Add 'emptymatch', 'noemptymatch' options to regular expressions. Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	1496
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1497 ## 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	1498 %!assert (regexprep ("a[b]c{d}e-f=g", "[^A-Za-z0-9_]", "_"), "a_b_c_d_e_f_g")
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1499
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1500 ## 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	1501 %!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	1502 %!assert (regexprep ("a[b]c{d}e-f=g", "g", "_"), "a[b]c{d}e-f=_")
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1503
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1504 ## Options
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1505 %!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	1506 %!assert (regexprep ("a[b]c{d}e-f=g", "[^A-Z0-9_]", "_", "ignorecase"), "a_b_c_d_e_f_g")
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1507
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1508 ## Option combinations
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1509 %!assert (regexprep ("a[b]c{d}e-f=g", "[^A-Z0-9_]", "_", "once", "ignorecase"), "a_b]c{d}e-f=g")
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1510
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1511 ## 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	1512 %!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	1513 %!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	1514 %!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	1515 %!assert (regexprep ("abc", "(b)", "$1.."), "ab..c");
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1516
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1517 ## 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	1518 %!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	1519 %!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	1520 %!assert (regexprep ({"abc","cba"}, {"b","a"}, {"?","!"}), {"!?c","c?!"})
6361 776e657c9422 [project @ 2007-02-27 09:45:03 by dbateman] dbateman parents: 5866 diff changeset	1521
8093 dcc31f473596 Treat PCRE lookbehind operators in a manner that is approximately correct David Bateman <dbateman@free.fr> parents: 8021 diff changeset	1522 # Nasty lookbehind expression
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14496 diff changeset	1523 %!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	1524
e47d929fde8f process backslash string escapes in regexp pattern and regexprep replacement (bug #35911) John W. Eaton <jwe@octave.org> parents: 14536 diff changeset	1525 %!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	1526 %!assert (regexprep ("\n", "\n", "X"), "X");
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5779 diff changeset	1527 */

Mercurial > octave-nkf

annotate libinterp/corefcn/regexp.cc @ 20590:1a0a433c8263