# HG changeset patch # User jwe # Date 1134609005 0 # Node ID 6bf56668b01a2983864a00b37f9b10f7e42aeac7 # Parent 79ecf64976cef84447517f68245c13246b938291 [project @ 2005-12-15 01:08:20 by jwe] diff -r 79ecf64976ce -r 6bf56668b01a doc/ChangeLog --- a/doc/ChangeLog Wed Dec 14 21:46:10 2005 +0000 +++ b/doc/ChangeLog Thu Dec 15 01:10:05 2005 +0000 @@ -1,3 +1,10 @@ +2005-12-14 David Bateman + + * interpreter/testfun.txi: New test/demo documentation. + * interpreter/strings.txi: Include regexp/regexi docstrings. + * interpreter/octave.texi: Include test/demo appendix. + * interpreter/Makefile.in (SUB_SOURCE): Include test.txi. + 2005-12-13 David Bateman * interpreter/sparse.txi: Add new gplot, etreeplot and treeplot diff -r 79ecf64976ce -r 6bf56668b01a doc/interpreter/Makefile.in --- a/doc/interpreter/Makefile.in Wed Dec 14 21:46:10 2005 +0000 +++ b/doc/interpreter/Makefile.in Thu Dec 15 01:10:05 2005 +0000 @@ -27,7 +27,7 @@ op-idx.txi optim.txi plot.txi poly.txi preface.txi \ quad.txi quaternion.txi set.txi signal.txi sparse.txi stats.txi \ stmt.txi stream.txi strings.txi struct.txi system.txi \ - tips.txi var.txi vr-idx.txi + testfun.txi tips.txi var.txi vr-idx.txi SOURCES := $(SUB_SOURCE) diff -r 79ecf64976ce -r 6bf56668b01a doc/interpreter/octave.texi --- a/doc/interpreter/octave.texi Wed Dec 14 21:46:10 2005 +0000 +++ b/doc/interpreter/octave.texi Thu Dec 15 01:10:05 2005 +0000 @@ -154,6 +154,7 @@ * Audio Processing:: * Quaternions:: * System Utilities:: +* Test and Demo Functions:: * Tips:: * Trouble:: If you have trouble installing Octave. * Installation:: How to configure, compile and install Octave. @@ -454,6 +455,11 @@ * Group Database Functions:: * System Information:: +Test and Demo Functions + +* Test Functions:: +* Demonstration Functions:: + Tips and Standards * Style Tips:: Writing clean and robust programs. @@ -546,6 +552,7 @@ @c for them, and there appears to be no way to go back to the original @c set of indices once a redirection has taken place. +@include testfun.texi @include tips.texi @include bugs.texi @include install.texi diff -r 79ecf64976ce -r 6bf56668b01a doc/interpreter/strings.txi --- a/doc/interpreter/strings.txi Wed Dec 14 21:46:10 2005 +0000 +++ b/doc/interpreter/strings.txi Thu Dec 15 01:10:05 2005 +0000 @@ -162,6 +162,10 @@ @DOCSTRING(substr) +@DOCSTRING(regexp) + +@DOCSTRING(regexpi) + @node String Conversions @section String Conversions diff -r 79ecf64976ce -r 6bf56668b01a doc/interpreter/testfun.txi --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/doc/interpreter/testfun.txi Thu Dec 15 01:10:05 2005 +0000 @@ -0,0 +1,283 @@ +@c Copyright (C) 2005 David Bateman +@c Copyright (C) 2002-2005 Paul Kienzle +@c This is part of the Octave manual. +@c For copying conditions, see the file gpl.texi. + +@node Test and Demo Functions +@appendix Test and Demo Functions +@cindex test functions + +Octave includes a number of functions to allow the integration of testing +and demonstration code in the source code of the functions themselves. + +@menu +* Test Functions:: +* Demonstration Functions:: +@end menu + +@node Test Functions +@section Test Functions + +@DOCSTRING(test) + +@code{test} scans the named script file looking for lines which +start with @code{%!}. The prefix is stripped off and the rest of the +line is processed through the octave interpreter. If the code +generates an error, then the test is said to fail. + +Since @code{eval()} will stop at the first error it encounters, you must +divide your tests up into blocks, with anything in a separate +block evaluated separately. Blocks are introduced by the keyword +@code{test} immediately following the @code{%!}. For example, + +@example +@group + %!test error("this test fails!"); + %!test "this test doesn't fail since it doesn't generate an error"; +@end group +@end example + +When a test fails, you will see something like: + +@example +@group + ***** test error('this test fails!') + !!!!! test failed + this test fails! +@end group +@end example + +Generally, to test if something works, you want to assert that it +produces a correct value. A real test might look something like + +@example +@group + %!test + %! @var{a} = [1, 2, 3; 4, 5, 6]; B = [1; 2]; + %! expect = [ @var{a} ; 2*@var{a} ]; + %! get = kron (@var{b}, @var{a}); + %! if (any(size(expect) != size(get))) + %! error ("wrong size: expected %d,%d but got %d,%d", + %! size(expect), size(get)); + %! elseif (any(any(expect!=get))) + %! error ("didn't get what was expected."); + %! endif +@end group +@end example + +To make the process easier, use the @code{assert} function. For example, +with @code{assert} the previous test is reduced to: + +@example +@group + %!test + %! @var{a} = [1, 2, 3; 4, 5, 6]; @var{b} = [1; 2]; + %! assert (kron (@var{b}, @var{a}), [ @var{a}; 2*@var{a} ]); +@end group +@end example + +@code{assert} can accept a tolerance so that you can compare results +absolutely or relatively. For example, the following all succeed: + +@example +@group + %!test assert (1+eps, 1, 2*eps) # absolute error + %!test assert (100+100*eps, 100, -2*eps) # relative error +@end group +@end example + +You can also do the comparison yourself, but still have assert +generate the error: + +@example +@group + %!test assert (isempty([])) + %!test assert ([ 1,2; 3,4 ] > 0) +@end group +@end example + +Because @code{assert} is so frequently used alone in a test block, there +is a shorthand form: + +@example + %!assert (@dots{}) +@end example + +which is equivalent to: + +@example + %!test assert (@dots{}) +@end example + +Each block is evaluated in its own function environment, which means +that variables defined in one block are not automatically shared +with other blocks. If you do want to share variables, then you +must declare them as @code{shared} before you use them. For example, the +following declares the variable @var{a}, gives it an initial value (default +is empty), then uses it in several subsequent tests. + +@example +@group + %!shared @var{a} + %! @var{a} = [1, 2, 3; 4, 5, 6]; + %!assert (kron ([1; 2], @var{a}), [ @var{a}; 2*@var{a} ]); + %!assert (kron ([1, 2], @var{a}), [ @var{a}, 2*@var{a} ]); + %!assert (kron ([1,2; 3,4], @var{a}), [ @var{a},2*@var{a}; 3*@var{a},4*@var{a} ]); +@end group +@end example + +You can share several variables at the same time: + +@example + %!shared @var{a}, @var{b} +@end example + +You can also share test functions: + +@example +@group + %!function @var{a} = fn(@var{b}) + %! @var{a} = 2*@var{b}; + %!assert (@var{a}(2),4); +@end group +@end example + +Note that all previous variables and values are lost when a new +shared block is declared. + +Error and warning blocks are like test blocks, but they only succeed +if the code generates an error. You can check the text of the error +is correct using an optional regular expression @code{}. +For example: + +@example + %!error error('this test passes!'); +@end example + +If the code doesn't generate an error, the test fails. For example, + +@example + %!error "this is an error because it succeeds."; +@end example + +produces + +@example +@group + ***** error "this is an error because it succeeds."; + !!!!! test failed: no error +@end group +@end example + +It is important to automate the tests as much as possible, however +some tests require user interaction. These can be isolated into +demo blocks, which if you are in batch mode, are only run when +called with @code{demo} or @code{verbose}. The code is displayed before +it is executed. For example, + +@example +@group + %!demo + %! @var{t}=[0:0.01:2*pi]; @var{x}=sin(@var{t}); + %! plot(@var{t},@var{x}); + %! you should now see a sine wave in your figure window +@end group +@end example + +produces + +@example +@group + > @var{t}=[0:0.01:2*pi]; @var{x}=sin(@var{t}); + > plot(@var{t},@var{x}); + > you should now see a sine wave in your figure window + Press to continue: +@end group +@end example + +Note that demo blocks cannot use any shared variables. This is so +that they can be executed by themselves, ignoring all other tests. + +If you want to temporarily disable a test block, put @code{#} in place +of the block type. This creates a comment block which is echoed +in the log file, but is not executed. For example: + +@example +@group + %!#demo + %! @var{t}=[0:0.01:2*pi]; @var{x}=sin(@var{t}); + %! plot(@var{t},@var{x}); + %! you should now see a sine wave in your figure window +@end group +@end example + +Block type summary: + +@table @code +@item %!test +check that entire block is correct +@item %!error +check for correct error message +@item %!warning +check for correct warning message +@item %!demo +demo only executes in interactive mode +@item %!# +comment: ignore everything within the block +@item %!shared x,y,z +declares variables for use in multiple tests +@item %!function +defines a function value for a shared variable +@item %!assert (x, y, tol) +shorthand for %!test assert (x, y, tol) +@end table + +You can also create test scripts for builtins and your own C++ +functions. Just put a file of the function name on your path without +any extension and it will be picked up by the test procedure. You +can even embed tests directly in your C++ code: + +@example +@group + #if 0 + %!test disp('this is a test') + #endif +@end group +@end example + +or + +@example +@group + /* + %!test disp('this is a test') + */ +@end group +@end example + +but then the code will have to be on the load path and the user +will have to remember to type test('name.cc'). Conversely, you +can separate the tests from normal octave script files by putting +them in plain files with no extension rather than in script files. +@c DO I WANT TO INCLUDE THE EDITOR SPECIFIC STATEMENT BELOW??? +@c Don't forget to tell emacs that the plain text file you are using +@c is actually octave code, using something like: +@c -*-octave-*- + +@DOCSTRING(assert) + +@DOCSTRING(fail) + +@node Demonstration Functions +@section Demonstration Functions + +@DOCSTRING(demo) + +@DOCSTRING(example) + +@DOCSTRING(speed) + + +@c Local Variables: *** +@c Mode: texinfo *** +@c End: *** diff -r 79ecf64976ce -r 6bf56668b01a src/ChangeLog --- a/src/ChangeLog Wed Dec 14 21:46:10 2005 +0000 +++ b/src/ChangeLog Thu Dec 15 01:10:05 2005 +0000 @@ -1,3 +1,26 @@ +2005-12-14 John W. Eaton + + * oct-stream.cc (octave_stream::invalid_stream_error): Delete. + * oct-stream.h (octave_stream::stream_ok): Don't fail with error. + +2005-12-14 David Bateman + + * DLD-FUNCTIONS/regexp.cc: New file. + + * DLD-FUNCTIONS/dispatch.cc: Update tests for string/sq_string + differences. + + * error.cc (Vquiet_warning): New variable. + (vwarning): Use Vquiet_warning to prevent warning output. + (Fwarning): Include "quiet" option to Fwarning function. + Assign retval when using "query". Typo in error message. + (Flastwarn): Clear warning_state when using Flastwarn to probe warning + message. + + * ov-struct.cc: Update Fstruct tests for change in error output. + + * Makefile.in: Include regexp when needed with appropriate libraries. + 2005-12-13 David Bateman * Makefile.in: Change references to gplot.l to __gnuplot_raw__.l. diff -r 79ecf64976ce -r 6bf56668b01a src/DLD-FUNCTIONS/dispatch.cc --- a/src/DLD-FUNCTIONS/dispatch.cc Wed Dec 14 21:46:10 2005 +0000 +++ b/src/DLD-FUNCTIONS/dispatch.cc Thu Dec 15 01:10:05 2005 +0000 @@ -485,12 +485,12 @@ %!test # builtin function replacement %! dispatch('sin','length','string') -%! assert(sin('abc'),3) +%! assert(sin("abc"),3) %! assert(sin(0),0,10*eps); %!test # 'any' function %! dispatch('sin','exp','any') %! assert(sin(0),1,eps); -%! assert(sin('abc'),3); +%! assert(sin("abc"),3); %!test # 'builtin' function %! assert(builtin('sin',0),0,eps); %! builtin('eval','x=1;'); @@ -502,25 +502,25 @@ %!test # oct-file replacement %! dispatch('fft','length','string') %! assert(fft([1,1]),[2,0]); -%! assert(fft('abc'),3) +%! assert(fft("abc"),3) %! dispatch('fft','string'); %!test # m-file replacement %! dispatch('hamming','length','string') %! assert(hamming(1),1) -%! assert(hamming('abc'),3) +%! assert(hamming("abc"),3) %! dispatch('hamming','string') %!test # override preloaded builtin %! evalin('base','cos(1);'); %! dispatch('cos','length','string') -%! evalin('base',"assert(cos('abc'),3)"); -%! evalin('base',"assert(cos(0),1,eps)"); +%! evalin('base','assert(cos("abc"),3)'); +%! evalin('base','assert(cos(0),1,eps)'); %! dispatch('cos','string') %!test # override pre-loaded oct-file %! evalin('base','qr(1);'); %! dispatch('qr','length','string') -%! evalin('base',"assert(qr('abc'),3)"); -%! evalin('base',"assert(qr(1),1)"); +%! evalin('base','assert(qr("abc"),3)'); +%! evalin('base','assert(qr(1),1)'); %! dispatch('qr','string'); %!test # override pre-loaded m-file %! evalin('base','hanning(1);'); @@ -536,11 +536,11 @@ %! system("echo 'function a=dispatch_x(a)'>dispatch_x.m"); %! dispatch('dispatch_x','length','string') %! assert(dispatch_x(3),3) -%! assert(dispatch_x('a'),1) +%! assert(dispatch_x("a"),1) %! pause(1); %! system("echo 'function a=dispatch_x(a),++a;'>dispatch_x.m"); %! assert(dispatch_x(3),4) -%! assert(dispatch_x('a'),1) +%! assert(dispatch_x("a"),1) %!test %! system("rm dispatch_x.m"); diff -r 79ecf64976ce -r 6bf56668b01a src/DLD-FUNCTIONS/regexp.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/DLD-FUNCTIONS/regexp.cc Thu Dec 15 01:10:05 2005 +0000 @@ -0,0 +1,741 @@ +/* + +Copyright (C) 2005 David Bateman +Copyright (C) 2002-2005 Paul Kienzle + +Octave is free software; you can redistribute it and/or modify it +under the terms of the GNU General Public License as published by the +Free Software Foundation; either version 2, or (at your option) any +later version. + +Octave is distributed in the hope that it will be useful, but WITHOUT +ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with this program; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, +Boston, MA 02110-1301, USA. + +*/ + +// XXX FIXME XXX +// regexprep should be written as an m-file based on regexp + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include "defun-dld.h" +#include "error.h" +#include "gripes.h" +#include "oct-obj.h" +#include "utils.h" + +#include "Cell.h" +#include "oct-map.h" +#include "str-vec.h" + +#ifdef HAVE_PCRE +#include +#else +#ifdef HAVE_REGEX +#ifdef __MINGW32__ +#define __restrict +#endif +#include +#endif +#endif + +static octave_value_list +octregexp (const octave_value_list &args, int nargout, const std::string &nm, + bool case_insensitive) +{ + octave_value_list retval; +#if defined (HAVE_REGEX) || defined (HAVE_PCRE) + int nargin = args.length(); + int nopts = nargin - 2; + bool once = false; + + if (nargin < 2) + { + print_usage(nm); + return retval; + } + + std::string buffer = args(0).string_value (); + if (error_state) + { + gripe_wrong_type_arg (nm.c_str(), args(0)); + return retval; + } + + std::string pattern = args(1).string_value (); + if (error_state) + { + gripe_wrong_type_arg (nm.c_str(), args(1)); + return retval; + } + + for (int i = 2; i < nargin; i++) + { + std::string str = args(i).string_value(); + if (error_state) + { + error ("%s: optional arguments must be strings", nm.c_str()); + break; + } + std::transform (str.begin (), str.end (), str.begin (), tolower); + if (str.find("once", 0) == 0) + { + once = true; + nopts--; + } +#ifdef HAVE_PCRE + // XXX FIXME XXX named tokens still broken. Disable for now +#if 0 + else if (str.find("start", 0) && str.find("end", 0) && + str.find("tokenextents", 0) && str.find("match", 0) && + str.find("tokens", 0) && str.find("names", 0)) + error ("%s: unrecognized option", nm.c_str()); +#else + else if (str.find("names", 0) == 0) + error ("%s: named tokens not implemented in this version", nm.c_str()); + else if (str.find("start", 0) && str.find("end", 0) && + str.find("tokenextents", 0) && str.find("match", 0) && + str.find("tokens", 0)) + error ("%s: unrecognized option", nm.c_str()); +#endif +#else + else if (str.find("names", 0) == 0) + error ("%s: named tokens not implemented in this version", nm.c_str()); + else if (str.find("start", 0) && str.find("end", 0) && + str.find("tokenextents", 0) && str.find("match", 0) && + str.find("tokens", 0)) + error ("%s: unrecognized option", nm.c_str()); +#endif + } + + if (!error_state) + { + Octave_map nmap; + Cell t, m, te; + NDArray s, e; + + // named tokens "(?...)" are only treated with PCRE not regex. +#if HAVE_PCRE + // The syntax of named tokens in pcre is "(?P...)" while we need + // a syntax "(?...)", so fix that here. Also an expression like + // "(?\w+)\s+(?\w+)|(?\w+),\s+(?\w+)" should + // be perfectly legal, while pcre does not allow the same named token + // name of both sides of the alternative. Also fix that here by replacing + // duplicate name tokens by dummy names, and dealing with the dummy names + // later. + + + + + // Compile expression + pcre *re; + const char *err; + int erroffset; + re = pcre_compile(pattern.c_str(), (case_insensitive ? PCRE_CASELESS : 0), + &err, &erroffset, NULL); + + if (re == NULL) { + error("%s: %s at position %d of expression", nm.c_str(), + err, erroffset); + return retval; + } + + int subpatterns; + int namecount; + int nameentrysize; + char *nametable; + int idx = 0; + int sz = 0; + + pcre_fullinfo(re, NULL, PCRE_INFO_CAPTURECOUNT, &subpatterns); + pcre_fullinfo(re, NULL, PCRE_INFO_NAMECOUNT, &namecount); + pcre_fullinfo(re, NULL, PCRE_INFO_NAMEENTRYSIZE, &nameentrysize); + pcre_fullinfo(re, NULL, PCRE_INFO_NAMETABLE, &nametable); + + OCTAVE_LOCAL_BUFFER(int, ovector, (subpatterns+1)*3); + OCTAVE_LOCAL_BUFFER(int, nidx, namecount); + string_vector names (namecount); + + for (int i = 0; i < namecount; i++) + { + // Index of subpattern in first two bytes MSB first of name. + // Extract name and index. + nidx[i] = ((int)nametable[i*nameentrysize]) << 8 | + (int)nametable[i*nameentrysize+1]; + names(i) = std::string((&(nametable[i*nameentrysize+2]))); + } + + Cell named_tokens(dim_vector(namecount,1)); + + while(true) + { + int matches = pcre_exec(re, NULL, buffer.c_str(), + buffer.length(), idx, + (idx ? PCRE_NOTBOL : 0), + ovector, (subpatterns+1)*3); + + if (matches < 0 && matches != PCRE_ERROR_NOMATCH) + { + error ("%s: internal error calling pcre_exec", nm.c_str()); + pcre_free(re); + return retval; + } + else if (matches == PCRE_ERROR_NOMATCH) + break; + else + { + s.resize (dim_vector(1, sz+1)); + s(sz) = double (ovector[0]+1); + e.resize (dim_vector(1, sz+1)); + e(sz) = double (ovector[1]); + te.resize(dim_vector(1, sz+1)); + Matrix mat_te(matches-1,2); + for (int i = 1; i < matches; i++) + { + mat_te(i-1,0) = double (ovector[2*i]+1); + mat_te(i-1,1) = double (ovector[2*i+1]); + } + te(sz) = mat_te; + + const char **listptr; + int status = pcre_get_substring_list(buffer.c_str(), ovector, + matches, &listptr); + + if (status == PCRE_ERROR_NOMEMORY) { + error("%s: cannot allocate memory in pcre_get_substring_list", + nm.c_str()); + pcre_free(re); + return retval; + } + + m.resize (dim_vector(1, sz+1)); + m(sz) = std::string(*listptr); + + t.resize (dim_vector(1, sz+1)); + Cell cell_t (dim_vector(1,matches-1)); + for (int i = 1; i < matches; i++) + cell_t(i-1) = std::string(*(listptr+i)); + t(sz) = cell_t; + + for (int i = 0; i < namecount; i++) + { + Cell tmp = named_tokens(i); + tmp.resize(dim_vector(1,sz+1)); + tmp(sz) = + std::string(*(listptr+nidx[i])); + named_tokens(i) = tmp; + } + + pcre_free_substring_list(listptr); + + if (once) + break; + + idx = ovector[1]; + sz++; + } + } + + for (int i = 0; i < namecount; i++) + nmap.assign (names(i), named_tokens(i)); + + pcre_free(re); +#else + regex_t compiled; + int err=regcomp(&compiled, pattern.c_str(), REG_EXTENDED | + (case_insensitive ? REG_ICASE : 0)); + if (err) + { + int len = regerror(err, &compiled, NULL, 0); + char *errmsg = (char *)malloc(len); + if (errmsg) + { + regerror(err, &compiled, errmsg, len); + error("%s: %s in pattern (%s)", nm.c_str(), errmsg, + pattern.c_str()); + free(errmsg); + } + else + { + error("out of memory"); + } + regfree(&compiled); + return retval; + } + + int subexpr = 1; + int idx = 0; + int sz = 0; + for (unsigned int i=0; i < pattern.length(); i++) + subexpr += ( pattern[i] == '(' ? 1 : 0 ); + OCTAVE_LOCAL_BUFFER (regmatch_t, match, subexpr ); + + while(true) + { + if (regexec(&compiled, buffer.c_str() + idx, subexpr, + match, (idx ? REG_NOTBOL : 0)) == 0) + { + // Count actual matches + int matches = 0; + while (matches < subexpr && match[matches].rm_so >= 0) + matches++; + + s.resize (dim_vector(1, sz+1)); + s(sz) = double (match[0].rm_so+1+idx); + e.resize (dim_vector(1, sz+1)); + e(sz) = double (match[0].rm_eo+idx); + te.resize(dim_vector(1, sz+1)); + Matrix mat_te(matches-1,2); + for (int i = 1; i < matches; i++) + { + mat_te(i-1,0) = double (match[i].rm_so+1+idx); + mat_te(i-1,1) = double (match[i].rm_eo+idx); + } + te(sz) = mat_te; + + m.resize (dim_vector(1, sz+1)); + m(sz) = buffer.substr (match[0].rm_so+idx, + match[0].rm_eo-match[0].rm_so); + + t.resize (dim_vector(1, sz+1)); + Cell cell_t (dim_vector(1,matches-1)); + for (int i = 1; i < matches; i++) + cell_t(i-1) = buffer.substr (match[i].rm_so+idx, + match[i].rm_eo-match[i].rm_so); + t(sz) = cell_t; + + idx += match[0].rm_eo; + sz++; + + if (once) + break; + } + else + break; + } + regfree(&compiled); +#endif + + retval(5) = nmap; + retval(4) = t; + retval(3) = m; + retval(2) = te; + retval(1) = e; + retval(0) = s; + + // Alter the order of the output arguments + if (nopts > 0) + { + int n = 0; + octave_value_list new_retval; + new_retval.resize(nargout); + + OCTAVE_LOCAL_BUFFER (int, arg_used, 6); + for (int i = 0; i < 6; i++) + arg_used[i] = false; + + for (int i = 2; i < nargin; i++) + { + int k = 0; + std::string str = args(i).string_value(); + std::transform (str.begin (), str.end (), str.begin (), tolower); + if (str.find("once", 0) == 0) + continue; + else if (str.find("start", 0) == 0) + k = 0; + else if (str.find("end", 0) == 0) + k = 1; + else if (str.find("tokenextents", 0) == 0) + k = 2; + else if (str.find("match", 0) == 0) + k = 3; + else if (str.find("tokens", 0) == 0) + k = 4; + else if (str.find("names", 0) == 0) + k = 5; + + new_retval(n++) = retval(k); + arg_used[k] = true; + + if (n == nargout) + break; + } + + // Fill in the rest of the arguments + if (n < nargout) + { + for (int i = 0; i < 6; i++) + { + if (! arg_used[i]) + new_retval(n++) = retval(i); + } + } + + retval = new_retval; + } + } + +#else + error ("%s: not available in this version of Octave", nm); +#endif + return retval; +} + +DEFUN_DLD (regexp, args, nargout, + "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} {[@var{s}, @var{e}, @var{te}, @var{m}, @var{t}, @var{nm}] =} regexp (@var{str}, @var{pat})\n\ +@deftypefnx {Loadable Function} {[@dots{}] =} regexp (@var{str}, @var{pat}, @var{opts}, @dots{})\n\ +\n\ +Regular expression string matching. Matches @var{pat} in @var{str} and\n\ +returns the position and matching substrings or empty values if there are\n\ +none.\n\ +\n\ +The matched pattern @var{pat} can include any of the standard regex\n\ +operators, including:\n\ +\n\ +@table @code\n\ +@item .\n\ +Match any character\n\ +@item * + ? @{@}\n\ +Repetition operators, representing\n\ +@table @code\n\ +@item *\n\ +Match zero or more times\n\ +@item +\n\ +Match one or more times\n\ +@item ?\n\ +Match zero or one times\n\ +@item @{@}\n\ +Match range operator, which is of the form @code{@{@var{n}@}} to match exactly\n\ +@var{n} times, @code{@{@var{m},@}} to match @var{m} or more times,\n\ +@code{@{@var{m},@var{n}@}} to match between @var{m} and @var{n} times.\n\ +@end table\n\ +@item [@dots{}] [^@dots{}]\n\ +List operators, where for example @code{[ab]c} matches @code{ac} and @code{bc}\n\ +@item ()\n\ +Grouping operator\n\ +@item |\n\ +Alternation operator. Match one of a choice of regular expressions. The\n\ +alternatives must be delimited by the grouoing operator @code{()} above\n\ +@item ^ $\n\ +Anchoring operator. @code{^} matches the start of the string @var{str} and\n\ +@code{$} the end\n\ +@end table\n\ +\n\ +In addition the following escaped characters have special meaning. It should\n\ +be noted that it is recommended to quote @var{pat} in single quotes rather\n\ +than double quotes, to avoid the escape sequences being interpreted by octave\n\ +before being passed to @code{regexp}.\n\ +\n\ +@table @code\n\ +@item \\b\n\ +Match a word boundary\n\ +@item \\B\n\ +Match within a word\n\ +@item \\w\n\ +Matches any word character\n\ +@item \\W\n\ +Matches any non word character\n\ +@item \\<\n\ +Matches the beginning of a word\n\ +@item \\>\n\ +Matches the end of a word\n\ +@item \\s\n\ +Matches any whitespace character\n\ +@item \\S\n\ +Matches any non whitespace character\n\ +@item \\d\n\ +Matches any digit\n\ +@item \\D\n\ +Matches any non-digit\n\ +@end table\n\ +\n\ +The outputs of @code{regexp} by default are in the order as given below\n\ +\n\ +@table @asis\n\ +@item @var{s}\n\ +The start indices of each of the matching substrings\n\ +\n\ +@item @var{e}\n\ +The end indices of each matching substring\n\ +\n\ +@item @var{te}\n\ +The extents of each of the matched token surrounded by @code{(@dots{})} in\n\ +@var{pat}.\n\ +\n\ +@item @var{m}\n\ +A cell array of the text of each match.\n\ +\n\ +@item @var{t}\n\ +A cell array of the text of each token matched.\n\ +\n\ +@item @var{nm}\n\ +A structure containing the text of each matched named token, with the name\n\ +being used as the fieldname. A named token is denoted as\n\ +@code{(?@dots{})}\n\ +@end table\n\ +\n\ +Particular output arguments or the order of the output arguments can be\n\ +selected by additional @var{opts} arguments. These are strings and the\n\ +correspondence between the output arguments and the optional argument\n\ +are\n\ +\n\ +@multitable @columnfractions 0.2 0.3 0.3 0.2\n\ +@item @tab 'start' @tab @var{s} @tab\n\ +@item @tab 'end' @tab @var{e} @tab\n\ +@item @tab 'tokenExtents' @tab @var{te} @tab\n\ +@item @tab 'match' @tab @var{m} @tab\n\ +@item @tab 'tokens' @tab @var{t} @tab\n\ +@item @tab 'names' @tab @var{nm} @tab\n\ +@end multitable\n\ +\n\ +A further optional argument is 'once', that limits the number of returned\n\ +matches to the first match.\n\ +@end deftypefn") +{ + return octregexp (args, nargout, "regexp", false); +} + +/* + +## seg-fault test +%!assert(regexp("abcde","."),[1,2,3,4,5]) + +## Check that anchoring of pattern works correctly +%!assert(regexp('abcabc','^abc'),1); +%!assert(regexp('abcabc','abc$'),4); +%!assert(regexp('abcabc','^abc$'),[]); + +%!test +%! [s, e, te, m, t] = regexp(' No Match ', 'f(.*)uck'); +%! assert (s,[]) +%! assert (e,[]) +%! assert (te,{}) +%! assert (m, {}) +%! assert (t, {}) + +%!test +%! [s, e, te, m, t] = regexp(' FiRetrUck ', 'f(.*)uck'); +%! assert (s,[]) +%! assert (e,[]) +%! assert (te,{}) +%! assert (m, {}) +%! assert (t, {}) + +%!test +%! [s, e, te, m, t] = regexp(' firetruck ', 'f(.*)uck'); +%! assert (s,2) +%! assert (e,10) +%! assert (te{1},[3,7]) +%! assert (m{1}, 'firetruck') +%! assert (t{1}{1}, 'iretr') + +%!test +%! [s, e, te, m, t] = regexp('short test string','\w*r\w*'); +%! assert (s,[1,12]) +%! assert (e,[5,17]) +%! assert (size(te), [1,2]) +%! assert (isempty(te{1})) +%! assert (isempty(te{2})) +%! assert (m{1},'short') +%! assert (m{2},'string') +%! assert (size(t), [1,2]) +%! assert (isempty(t{1})) +%! assert (isempty(t{2})) + +%!test +%! [s, e, te, m, t] = regexp('short test string','\w*r\w*','once'); +%! assert (s,1) +%! assert (e,5) +%! assert (size(te), [1,1]) +%! assert (isempty(te{1})) +%! assert (m{1},'short') +%! ## Matlab gives [1,0] here but that seems wrong. +%! assert (size(t), [1,1]) + +%!test +%! [m, te, e, s, t] = regexp('short test string','\w*r\w*','once', 'match', 'tokenExtents', 'end', 'start', 'tokens'); +%! assert (s,1) +%! assert (e,5) +%! assert (size(te), [1,1]) +%! assert (isempty(te{1})) +%! assert (m{1},'short') +%! ## Matlab gives [1,0] here but that seems wrong. +%! assert (size(t), [1,1]) + +## XXX FIXME XXX Disable test for now as PCRE version not written +%!#test +%! ## This test is expected to fail if PCRE is not installed +%! [s, e, te, m, t, nm] = regexp('short test string','(?\w*t)\s*(?\w*t)'); +%! assert (s,1) +%! assert (e,10) +%! assert (size(te), [1,1]) +%! assert (te{1}, [1 5; 7, 10]) +%! assert (m{1},'short test') +%! assert (size(t),[1,1]) +%! assert (t{1}{1},'short') +%! assert (t{1}{2},'test') +%! assert (size(nm), [1,1]) +%! assert (isempty(fieldnames(nm))) +%! assert (sort(fieldnames(nm)),{'word1','word2'}) +%! assert (nm.word1,'short') +%! assert (nm.word2,'test') + +## XXX FIXME XXX Disable test for now as PCRE version not written +%!#test +%! ## This test is expected to fail if PCRE is not installed +%! [nm, m, te, e, s, t] = regexp('short test string','(?\w*t)\s*(?\w*t)', 'names', 'match', 'tokenExtents', 'end', 'start', 'tokens'); +%! assert (s,1) +%! assert (e,10) +%! assert (size(te), [1,1]) +%! assert (te{1}, [1 5; 7, 10]) +%! assert (m{1},'short test') +%! assert (size(t),[1,1]) +%! assert (t{1}{1},'short') +%! assert (t{1}{2},'test') +%! assert (size(nm), [1,1]) +%! assert (isempty(fieldnames(nm))) +%! assert (sort(fieldnames(nm)),{'word1','word2'}) +%! assert (nm.word1,'short') +%! assert (nm.word2,'test') + +%!error regexp('string', 'tri', 'BadArg'); +%!error regexp('string'); + +*/ + +DEFUN_DLD(regexpi, args, nargout, + "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} {[@var{s}, @var{e}, @var{te}, @var{m}, @var{t}, @var{nm}] =} regexpi (@var{str}, @var{pat})\n\ +@deftypefnx {Loadable Function} {[@dots{}] =} regexpi (@var{str}, @var{pat}, @var{opts}, @dots{})\n\ +\n\ +Case insensitive regular expression string matching. Matches @var{pat} in\n\ +@var{str} and returns the position and matching substrings or empty values\n\ +if there are none. See @code{regexp} for more details\n\ +@end deftypefn") +{ + return octregexp (args, nargout, "regexp", true); +} + +/* + +## seg-fault test +%!assert(regexpi("abcde","."),[1,2,3,4,5]) + +## Check that anchoring of pattern works correctly +%!assert(regexpi('abcabc','^abc'),1); +%!assert(regexpi('abcabc','abc$'),4); +%!assert(regexpi('abcabc','^abc$'),[]); + +%!test +%! [s, e, te, m, t] = regexpi(' No Match ', 'f(.*)uck'); +%! assert (s,[]) +%! assert (e,[]) +%! assert (te,{}) +%! assert (m, {}) +%! assert (t, {}) + +%!test +%! [s, e, te, m, t] = regexpi(' FiRetrUck ', 'f(.*)uck'); +%! assert (s,2) +%! assert (e,10) +%! assert (te{1},[3,7]) +%! assert (m{1}, 'FiRetrUck') +%! assert (t{1}{1}, 'iRetr') + +%!test +%! [s, e, te, m, t] = regexpi(' firetruck ', 'f(.*)uck'); +%! assert (s,2) +%! assert (e,10) +%! assert (te{1},[3,7]) +%! assert (m{1}, 'firetruck') +%! assert (t{1}{1}, 'iretr') + +%!test +%! [s, e, te, m, t] = regexpi('ShoRt Test String','\w*r\w*'); +%! assert (s,[1,12]) +%! assert (e,[5,17]) +%! assert (size(te), [1,2]) +%! assert (isempty(te{1})) +%! assert (isempty(te{2})) +%! assert (m{1},'ShoRt') +%! assert (m{2},'String') +%! assert (size(t), [1,2]) +%! assert (isempty(t{1})) +%! assert (isempty(t{2})) + +%!test +%! [s, e, te, m, t] = regexpi('ShoRt Test String','\w*r\w*','once'); +%! assert (s,1) +%! assert (e,5) +%! assert (size(te), [1,1]) +%! assert (isempty(te{1})) +%! assert (m{1},'ShoRt') +%! ## Matlab gives [1,0] here but that seems wrong. +%! assert (size(t), [1,1]) + +%!test +%! [m, te, e, s, t] = regexpi('ShoRt Test String','\w*r\w*','once', 'match', 'tokenExtents', 'end', 'start', 'tokens'); +%! assert (s,1) +%! assert (e,5) +%! assert (size(te), [1,1]) +%! assert (isempty(te{1})) +%! assert (m{1},'ShoRt') +%! ## Matlab gives [1,0] here but that seems wrong. +%! assert (size(t), [1,1]) + +## XXX FIXME XXX Disable test for now as PCRE version not written +%!#test +%! ## This test is expected to fail if PCRE is not installed +%! [s, e, te, m, t, nm] = regexpi('ShoRt Test String','(?\w*t)\s*(?\w*t)'); +%! assert (s,1) +%! assert (e,10) +%! assert (size(te), [1,1]) +%! assert (te{1}, [1 5; 7, 10]) +%! assert (m{1},'ShoRt Test') +%! assert (size(t),[1,1]) +%! assert (t{1}{1},'ShoRt') +%! assert (t{1}{2},'Test') +%! assert (size(nm), [1,1]) +%! assert (isempty(fieldnames(nm))) +%! assert (sort(fieldnames(nm)),{'word1','word2'}) +%! assert (nm.word1,'ShoRt') +%! assert (nm.word2,'Test') + +## XXX FIXME XXX Disable test for now as PCRE version not written +%!#test +%! ## This test is expected to fail if PCRE is not installed +%! [nm, m, te, e, s, t] = regexpi('ShoRt Test String','(?\w*t)\s*(?\w*t)', 'names', 'match', 'tokenExtents', 'end', 'start', 'tokens'); +%! assert (s,1) +%! assert (e,10) +%! assert (size(te), [1,1]) +%! assert (te{1}, [1 5; 7, 10]) +%! assert (m{1},'ShoRt Test') +%! assert (size(t),[1,1]) +%! assert (t{1}{1},'ShoRt') +%! assert (t{1}{2},'Test') +%! assert (size(nm), [1,1]) +%! assert (isempty(fieldnames(nm))) +%! assert (sort(fieldnames(nm)),{'word1','word2'}) +%! assert (nm.word1,'ShoRt') +%! assert (nm.word2,'Test') + +%!error regexpi('string', 'tri', 'BadArg'); +%!error regexpi('string'); + +*/ + +/* +;;; Local Variables: *** +;;; mode: C++ *** +;;; End: *** +*/ diff -r 79ecf64976ce -r 6bf56668b01a src/Makefile.in --- a/src/Makefile.in Wed Dec 14 21:46:10 2005 +0000 +++ b/src/Makefile.in Thu Dec 15 01:10:05 2005 +0000 @@ -49,9 +49,10 @@ filter.cc find.cc fsolve.cc gammainc.cc gcd.cc getgrent.cc \ getpwent.cc getrusage.cc givens.cc hess.cc inv.cc kron.cc \ lpsolve.cc lsode.cc lu.cc luinc.cc matrix_type.cc minmax.cc \ - pinv.cc qr.cc quad.cc qz.cc rand.cc schur.cc sort.cc sparse.cc \ - spchol.cc spdet.cc spkron.cc splu.cc spparms.cc sqrtm.cc svd.cc \ - syl.cc time.cc __gnuplot_raw__.l __glpk__.cc __qp__.cc + pinv.cc qr.cc quad.cc qz.cc rand.cc regexp.cc schur.cc sort.cc \ + sparse.cc spchol.cc spdet.cc spkron.cc splu.cc spparms.cc \ + sqrtm.cc svd.cc syl.cc time.cc \ + __gnuplot_raw__.l __glpk__.cc __qp__.cc DLD_SRC := $(addprefix DLD-FUNCTIONS/, $(DLD_XSRC)) @@ -241,7 +242,7 @@ $(LIBPLPLOT) $(LIBGLOB) $(LIBDLFCN) else OCTAVE_LIBS = $(LIBOCTINTERP) $(LIBOCTAVE) \ - $(GLPK_LIBS) $(SPECIAL_MATH_LIB) $(LIBCRUFT) \ + $(GLPK_LIBS) $(REGEX_LIBS) $(SPECIAL_MATH_LIB) $(LIBCRUFT) \ $(LIBPLPLOT) $(LIBGLOB) $(LIBDLFCN) endif @@ -569,9 +570,13 @@ ifeq ($(ENABLE_DYNAMIC_LINKING), true) ifdef CXXPICFLAG + regexp.oct : pic/regexp.o octave$(EXEEXT) + $(DL_LD) $(DL_LDFLAGS) -o $@ $< $(OCT_LINK_DEPS) $(REGEX_LIBS) __glpk__.oct : pic/__glpk__.o octave$(EXEEXT) $(DL_LD) $(DL_LDFLAGS) -o $@ $< $(OCT_LINK_DEPS) $(GLPK_LIBS) else + regexp.oct : regexp.o octave$(EXEEXT) + $(DL_LD) $(DL_LDFLAGS) -o $@ $< $(OCT_LINK_DEPS) $(REGEX_LIBS) __glpk__.oct : __glpk__.o octave$(EXEEXT) $(DL_LD) $(DL_LDFLAGS) -o $@ $< $(OCT_LINK_DEPS) $(GLPK_LIBS) endif diff -r 79ecf64976ce -r 6bf56668b01a src/error.cc --- a/src/error.cc Wed Dec 14 21:46:10 2005 +0000 +++ b/src/error.cc Thu Dec 15 01:10:05 2005 +0000 @@ -67,6 +67,10 @@ // TRUE means that Octave will print a verbose warning. Currently unused. static bool Vverbose_warning; +// TRUE means that Octave will print no warnings, but lastwarn will be +//updated +static bool Vquiet_warning = false; + // A structure containing (most of) the current state of warnings. static Octave_map warning_options; @@ -169,9 +173,12 @@ Vlast_warning_message = msg_string; } - octave_diary << msg_string; + if (! Vquiet_warning) + { + octave_diary << msg_string; - std::cerr << msg_string; + std::cerr << msg_string; + } } static void @@ -857,6 +864,14 @@ done = true; } } + else if (arg2 == "quiet") + { + if (arg1 != "error") + { + Vquiet_warning = (arg1 == "on"); + done = true; + } + } else { if (arg2 == "last") @@ -917,7 +932,7 @@ if (arg2 == "all") retval = warning_options; else if (arg2 == "backtrace" || arg2 == "debug" - || arg2 == "verbose") + || arg2 == "verbose" || arg2 == "quiet") { Octave_map tmp; tmp.assign ("identifier", arg2); @@ -925,8 +940,12 @@ tmp.assign ("state", Vbacktrace_on_warning ? "on" : "off"); else if (arg2 == "debug") tmp.assign ("state", Vdebug_on_warning ? "on" : "off"); + else if (arg2 == "verbose") + tmp.assign ("state", Vverbose_warning ? "on" : "off"); else - tmp.assign ("state", Vverbose_warning ? "on" : "off"); + tmp.assign ("state", Vquiet_warning ? "on" : "off"); + + retval = tmp; } else { @@ -1071,7 +1090,7 @@ } } else - error ("lastwarn: expecting arguments to be character strings"); + error ("lasterr: expecting arguments to be character strings"); } else print_usage ("lasterr"); @@ -1112,6 +1131,7 @@ if (argc == 1 || nargout > 0) { + warning_state = 0; retval(1) = prev_warning_id; retval(0) = prev_warning_message; } diff -r 79ecf64976ce -r 6bf56668b01a src/oct-stream.h --- a/src/oct-stream.h Wed Dec 14 21:46:10 2005 +0000 +++ b/src/oct-stream.h Thu Dec 15 01:10:05 2005 +0000 @@ -603,10 +603,7 @@ rep->clear (); } else - { - retval = false; - invalid_stream_error (who); - } + retval = false; return retval; } diff -r 79ecf64976ce -r 6bf56668b01a src/ov-struct.cc --- a/src/ov-struct.cc Wed Dec 14 21:46:10 2005 +0000 +++ b/src/ov-struct.cc Thu Dec 15 01:10:05 2005 +0000 @@ -498,8 +498,8 @@ %!assert(isstruct(x)); %!assert(isempty(fieldnames(x))); %!fail("struct('a',{1,2},'b',{1,2,3})","dimensions of parameter 2 do not match those of parameter 4") -%!fail("struct(1,2,3,4)","struct expects alternating 'field',value pairs"); -%!fail("struct('1',2,'3')","struct expects alternating 'field',value pairs"); +%!fail("struct(1,2,3,4)","struct expects alternating \"field\", VALUE pairs"); +%!fail("struct('1',2,'3')","struct expects alternating \"field\", VALUE pairs"); */ DEFUN (struct, args, ,