doc/doc-txt/pcretest.txt

   1 This file contains the PCRE man page that described the pcretest program. Note
   2 that not all of the features of PCRE are available in the limited version that
   3 is built with Exim.
   4 -------------------------------------------------------------------------------
   5
   6 PCRETEST(1)                                                        PCRETEST(1)
   7
   8
   9 NAME
  10        pcretest - a program for testing Perl-compatible regular expressions.
  11
  12
  13 SYNOPSIS
  14
  15        pcretest [options] [source] [destination]
  16
  17        pcretest  was written as a test program for the PCRE regular expression
  18        library itself, but it can also be used for experimenting with  regular
  19        expressions.  This document describes the features of the test program;
  20        for details of the regular expressions themselves, see the  pcrepattern
  21        documentation. For details of the PCRE library function calls and their
  22        options, see the pcreapi documentation.
  23
  24
  25 OPTIONS
  26
  27        -C        Output the version number of the PCRE library, and all avail-
  28                  able   information  about  the  optional  features  that  are
  29                  included, and then exit.
  30
  31        -d        Behave as if each regex has  the  /D  (debug)  modifier;  the
  32                  internal form is output after compilation.
  33
  34        -dfa      Behave  as if each data line contains the \D escape sequence;
  35                  this    causes    the    alternative    matching    function,
  36                  pcre_dfa_exec(),   to   be   used  instead  of  the  standard
  37                  pcre_exec() function (more detail is given below).
  38
  39        -i        Behave as if each regex  has  the  /I  modifier;  information
  40                  about the compiled pattern is given after compilation.
  41
  42        -m        Output  the  size  of each compiled pattern after it has been
  43                  compiled. This is equivalent to adding  /M  to  each  regular
  44                  expression.   For  compatibility  with  earlier  versions  of
  45                  pcretest, -s is a synonym for -m.
  46
  47        -o osize  Set the number of elements in the output vector that is  used
  48                  when  calling  pcre_exec()  to be osize. The default value is
  49                  45, which is enough for 14 capturing subexpressions. The vec-
  50                  tor  size  can  be  changed  for individual matching calls by
  51                  including \O in the data line (see below).
  52
  53        -p        Behave as if each regex has the /P modifier; the POSIX  wrap-
  54                  per  API  is used to call PCRE. None of the other options has
  55                  any effect when -p is set.
  56
  57        -q        Do not output the version number of pcretest at the start  of
  58                  execution.
  59
  60        -S size   On  Unix-like  systems,  set the size of the runtime stack to
  61                  size megabytes.
  62
  63        -t        Run each compile, study, and match many times with  a  timer,
  64                  and  output resulting time per compile or match (in millisec-
  65                  onds). Do not set -m with -t, because you will then  get  the
  66                  size  output  a  zillion  times,  and the timing will be dis-
  67                  torted.
  68
  69
  70 DESCRIPTION
  71
  72        If pcretest is given two filename arguments, it reads  from  the  first
  73        and writes to the second. If it is given only one filename argument, it
  74        reads from that file and writes to stdout.  Otherwise,  it  reads  from
  75        stdin  and  writes to stdout, and prompts for each line of input, using
  76        "re>" to prompt for regular expressions, and "data>" to prompt for data
  77        lines.
  78
  79        The program handles any number of sets of input on a single input file.
  80        Each set starts with a regular expression, and continues with any  num-
  81        ber of data lines to be matched against the pattern.
  82
  83        Each  data line is matched separately and independently. If you want to
  84        do multi-line matches, you have to use the \n escape sequence (or \r or
  85        \r\n,  depending  on  the newline setting) in a single line of input to
  86        encode the newline characters. There is no limit on the length of  data
  87        lines; the input buffer is automatically extended if it is too small.
  88
  89        An  empty  line signals the end of the data lines, at which point a new
  90        regular expression is read. The regular expressions are given  enclosed
  91        in any non-alphanumeric delimiters other than backslash, for example:
  92
  93          /(a|bc)x+yz/
  94
  95        White  space before the initial delimiter is ignored. A regular expres-
  96        sion may be continued over several input lines, in which case the  new-
  97        line  characters  are included within it. It is possible to include the
  98        delimiter within the pattern by escaping it, for example
  99
 100          /abc\/def/
 101
 102        If you do so, the escape and the delimiter form part  of  the  pattern,
 103        but  since delimiters are always non-alphanumeric, this does not affect
 104        its interpretation.  If the terminating delimiter is  immediately  fol-
 105        lowed by a backslash, for example,
 106
 107          /abc/\
 108
 109        then  a  backslash  is added to the end of the pattern. This is done to
 110        provide a way of testing the error condition that arises if  a  pattern
 111        finishes with a backslash, because
 112
 113          /abc\/
 114
 115        is  interpreted as the first line of a pattern that starts with "abc/",
 116        causing pcretest to read the next line as a continuation of the regular
 117        expression.
 118
 119
 120 PATTERN MODIFIERS
 121
 122        A  pattern may be followed by any number of modifiers, which are mostly
 123        single characters. Following Perl usage, these are  referred  to  below
 124        as,  for  example,  "the /i modifier", even though the delimiter of the
 125        pattern need not always be a slash, and no slash is used  when  writing
 126        modifiers.  Whitespace  may  appear between the final pattern delimiter
 127        and the first modifier, and between the modifiers themselves.
 128
 129        The /i, /m, /s, and /x modifiers set the PCRE_CASELESS, PCRE_MULTILINE,
 130        PCRE_DOTALL,  or  PCRE_EXTENDED  options,  respectively, when pcre_com-
 131        pile() is called. These four modifier letters have the same  effect  as
 132        they do in Perl. For example:
 133
 134          /caseless/i
 135
 136        The following table shows additional modifiers for setting PCRE options
 137        that do not correspond to anything in Perl:
 138
 139          /A       PCRE_ANCHORED
 140          /C       PCRE_AUTO_CALLOUT
 141          /E       PCRE_DOLLAR_ENDONLY
 142          /f       PCRE_FIRSTLINE
 143          /J       PCRE_DUPNAMES
 144          /N       PCRE_NO_AUTO_CAPTURE
 145          /U       PCRE_UNGREEDY
 146          /X       PCRE_EXTRA
 147          /<cr>    PCRE_NEWLINE_CR
 148          /<lf>    PCRE_NEWLINE_LF
 149          /<crlf>  PCRE_NEWLINE_CRLF
 150
 151        Those specifying line endings are literal strings as shown. Details  of
 152        the  meanings of these PCRE options are given in the pcreapi documenta-
 153        tion.
 154
 155    Finding all matches in a string
 156
 157        Searching for all possible matches within each subject  string  can  be
 158        requested  by  the  /g  or  /G modifier. After finding a match, PCRE is
 159        called again to search the remainder of the subject string. The differ-
 160        ence between /g and /G is that the former uses the startoffset argument
 161        to pcre_exec() to start searching at a  new  point  within  the  entire
 162        string  (which  is in effect what Perl does), whereas the latter passes
 163        over a shortened substring. This makes a  difference  to  the  matching
 164        process if the pattern begins with a lookbehind assertion (including \b
 165        or \B).
 166
 167        If any call to pcre_exec() in a /g or  /G  sequence  matches  an  empty
 168        string,  the next call is done with the PCRE_NOTEMPTY and PCRE_ANCHORED
 169        flags set in order to search for another, non-empty, match at the  same
 170        point.   If  this  second  match fails, the start offset is advanced by
 171        one, and the normal match is retried. This imitates the way  Perl  han-
 172        dles such cases when using the /g modifier or the split() function.
 173
 174    Other modifiers
 175
 176        There are yet more modifiers for controlling the way pcretest operates.
 177
 178        The /+ modifier requests that as well as outputting the substring  that
 179        matched  the  entire  pattern,  pcretest  should in addition output the
 180        remainder of the subject string. This is useful  for  tests  where  the
 181        subject contains multiple copies of the same substring.
 182
 183        The  /L modifier must be followed directly by the name of a locale, for
 184        example,
 185
 186          /pattern/Lfr_FR
 187
 188        For this reason, it must be the last modifier. The given locale is set,
 189        pcre_maketables()  is called to build a set of character tables for the
 190        locale, and this is then passed to pcre_compile()  when  compiling  the
 191        regular  expression.  Without  an  /L  modifier,  NULL is passed as the
 192        tables pointer; that is, /L applies only to the expression on which  it
 193        appears.
 194
 195        The  /I  modifier  requests  that pcretest output information about the
 196        compiled pattern (whether it is anchored, has a fixed first  character,
 197        and  so  on). It does this by calling pcre_fullinfo() after compiling a
 198        pattern. If the pattern is studied, the results of that are  also  out-
 199        put.
 200
 201        The /D modifier is a PCRE debugging feature, which also assumes /I.  It
 202        causes the internal form of compiled regular expressions to  be  output
 203        after compilation. If the pattern was studied, the information returned
 204        is also output.
 205
 206        The /F modifier causes pcretest to flip the byte order of the fields in
 207        the  compiled  pattern  that  contain  2-byte  and 4-byte numbers. This
 208        facility is for testing the feature in PCRE that allows it  to  execute
 209        patterns that were compiled on a host with a different endianness. This
 210        feature is not available when the POSIX  interface  to  PCRE  is  being
 211        used,  that is, when the /P pattern modifier is specified. See also the
 212        section about saving and reloading compiled patterns below.
 213
 214        The /S modifier causes pcre_study() to be called after  the  expression
 215        has been compiled, and the results used when the expression is matched.
 216
 217        The /M modifier causes the size of memory block used to hold  the  com-
 218        piled pattern to be output.
 219
 220        The  /P modifier causes pcretest to call PCRE via the POSIX wrapper API
 221        rather than its native API. When this  is  done,  all  other  modifiers
 222        except  /i,  /m, and /+ are ignored. REG_ICASE is set if /i is present,
 223        and REG_NEWLINE is set if /m is present. The  wrapper  functions  force
 224        PCRE_DOLLAR_ENDONLY  always, and PCRE_DOTALL unless REG_NEWLINE is set.
 225
 226        The /8 modifier causes pcretest to call PCRE with the PCRE_UTF8  option
 227        set.  This  turns on support for UTF-8 character handling in PCRE, pro-
 228        vided that it was compiled with this  support  enabled.  This  modifier
 229        also causes any non-printing characters in output strings to be printed
 230        using the \x{hh...} notation if they are valid UTF-8 sequences.
 231
 232        If the /? modifier  is  used  with  /8,  it  causes  pcretest  to  call
 233        pcre_compile()  with  the  PCRE_NO_UTF8_CHECK  option,  to suppress the
 234        checking of the string for UTF-8 validity.
 235
 236
 237 DATA LINES
 238
 239        Before each data line is passed to pcre_exec(),  leading  and  trailing
 240        whitespace  is  removed,  and it is then scanned for \ escapes. Some of
 241        these are pretty esoteric features, intended for checking out  some  of
 242        the  more  complicated features of PCRE. If you are just testing "ordi-
 243        nary" regular expressions, you probably don't need any  of  these.  The
 244        following escapes are recognized:
 245
 246          \a         alarm (= BEL)
 247          \b         backspace
 248          \e         escape
 249          \f         formfeed
 250          \n         newline
 251          \qdd       set the PCRE_MATCH_LIMIT limit to dd
 252                       (any number of digits)
 253          \r         carriage return
 254          \t         tab
 255          \v         vertical tab
 256          \nnn       octal character (up to 3 octal digits)
 257          \xhh       hexadecimal character (up to 2 hex digits)
 258          \x{hh...}  hexadecimal character, any number of digits
 259                       in UTF-8 mode
 260          \A         pass the PCRE_ANCHORED option to pcre_exec()
 261                       or pcre_dfa_exec()
 262          \B         pass the PCRE_NOTBOL option to pcre_exec()
 263                       or pcre_dfa_exec()
 264          \Cdd       call pcre_copy_substring() for substring dd
 265                       after a successful match (number less than 32)
 266          \Cname     call pcre_copy_named_substring() for substring
 267                       "name" after a successful match (name termin-
 268                       ated by next non alphanumeric character)
 269          \C+        show the current captured substrings at callout
 270                       time
 271          \C-        do not supply a callout function
 272          \C!n       return 1 instead of 0 when callout number n is
 273                       reached
 274          \C!n!m     return 1 instead of 0 when callout number n is
 275                       reached for the nth time
 276          \C*n       pass the number n (may be negative) as callout
 277                       data; this is used as the callout return value
 278          \D         use the pcre_dfa_exec() match function
 279          \F         only shortest match for pcre_dfa_exec()
 280          \Gdd       call pcre_get_substring() for substring dd
 281                       after a successful match (number less than 32)
 282          \Gname     call pcre_get_named_substring() for substring
 283                       "name" after a successful match (name termin-
 284                       ated by next non-alphanumeric character)
 285          \L         call pcre_get_substringlist() after a
 286                       successful match
 287          \M         discover the minimum MATCH_LIMIT and
 288                       MATCH_LIMIT_RECURSION settings
 289          \N         pass the PCRE_NOTEMPTY option to pcre_exec()
 290                       or pcre_dfa_exec()
 291          \Odd       set the size of the output vector passed to
 292                       pcre_exec() to dd (any number of digits)
 293          \P         pass the PCRE_PARTIAL option to pcre_exec()
 294                       or pcre_dfa_exec()
 295          \Qdd       set the PCRE_MATCH_LIMIT_RECURSION limit to dd
 296                       (any number of digits)
 297          \R         pass the PCRE_DFA_RESTART option to pcre_dfa_exec()
 298          \S         output details of memory get/free calls during matching
 299          \Z         pass the PCRE_NOTEOL option to pcre_exec()
 300                       or pcre_dfa_exec()
 301          \?         pass the PCRE_NO_UTF8_CHECK option to
 302                       pcre_exec() or pcre_dfa_exec()
 303          \>dd       start the match at offset dd (any number of digits);
 304                       this sets the startoffset argument for pcre_exec()
 305                       or pcre_dfa_exec()
 306          \<cr>      pass the PCRE_NEWLINE_CR option to pcre_exec()
 307                       or pcre_dfa_exec()
 308          \<lf>      pass the PCRE_NEWLINE_LF option to pcre_exec()
 309                       or pcre_dfa_exec()
 310          \<crlf>    pass the PCRE_NEWLINE_CRLF option to pcre_exec()
 311                       or pcre_dfa_exec()
 312
 313        The  escapes  that specify line endings are literal strings, exactly as
 314        shown.  A backslash followed by anything else just escapes the anything
 315        else.  If  the  very last character is a backslash, it is ignored. This
 316        gives a way of passing an empty line as data, since a real  empty  line
 317        terminates the data input.
 318
 319        If  \M  is present, pcretest calls pcre_exec() several times, with dif-
 320        ferent values in the match_limit and  match_limit_recursion  fields  of
 321        the  pcre_extra  data structure, until it finds the minimum numbers for
 322        each parameter that allow pcre_exec() to complete. The match_limit num-
 323        ber  is  a  measure of the amount of backtracking that takes place, and
 324        checking it out can be instructive. For most simple matches, the number
 325        is  quite  small,  but for patterns with very large numbers of matching
 326        possibilities, it can become large very quickly with increasing  length
 327        of subject string. The match_limit_recursion number is a measure of how
 328        much stack (or, if PCRE is compiled with  NO_RECURSE,  how  much  heap)
 329        memory is needed to complete the match attempt.
 330
 331        When  \O  is  used, the value specified may be higher or lower than the
 332        size set by the -O command line option (or defaulted to 45); \O applies
 333        only to the call of pcre_exec() for the line in which it appears.
 334
 335        If  the /P modifier was present on the pattern, causing the POSIX wrap-
 336        per API to be used, the only option-setting  sequences  that  have  any
 337        effect  are \B and \Z, causing REG_NOTBOL and REG_NOTEOL, respectively,
 338        to be passed to regexec().
 339
 340        The use of \x{hh...} to represent UTF-8 characters is not dependent  on
 341        the  use  of  the  /8 modifier on the pattern. It is recognized always.
 342        There may be any number of hexadecimal digits inside  the  braces.  The
 343        result  is from one to six bytes, encoded according to the UTF-8 rules.
 344
 345
 346 THE ALTERNATIVE MATCHING FUNCTION
 347
 348        By  default,  pcretest  uses  the  standard  PCRE  matching   function,
 349        pcre_exec() to match each data line. From release 6.0, PCRE supports an
 350        alternative matching function, pcre_dfa_test(),  which  operates  in  a
 351        different  way,  and has some restrictions. The differences between the
 352        two functions are described in the pcrematching documentation.
 353
 354        If a data line contains the \D escape sequence, or if the command  line
 355        contains  the -dfa option, the alternative matching function is called.
 356        This function finds all possible matches at a given point. If, however,
 357        the  \F escape sequence is present in the data line, it stops after the
 358        first match is found. This is always the shortest possible match.
 359
 360
 361 DEFAULT OUTPUT FROM PCRETEST
 362
 363        This section describes the output when the  normal  matching  function,
 364        pcre_exec(), is being used.
 365
 366        When a match succeeds, pcretest outputs the list of captured substrings
 367        that pcre_exec() returns, starting with number 0 for  the  string  that
 368        matched the whole pattern. Otherwise, it outputs "No match" or "Partial
 369        match" when pcre_exec() returns PCRE_ERROR_NOMATCH  or  PCRE_ERROR_PAR-
 370        TIAL,  respectively, and otherwise the PCRE negative error number. Here
 371        is an example of an interactive pcretest run.
 372
 373          $ pcretest
 374          PCRE version 5.00 07-Sep-2004
 375
 376            re> /^abc(\d+)/
 377          data> abc123
 378           0: abc123
 379           1: 123
 380          data> xyz
 381          No match
 382
 383        If the strings contain any non-printing characters, they are output  as
 384        \0x  escapes,  or  as \x{...} escapes if the /8 modifier was present on
 385        the pattern. If the pattern has the /+ modifier, the  output  for  sub-
 386        string  0 is followed by the the rest of the subject string, identified
 387        by "0+" like this:
 388
 389            re> /cat/+
 390          data> cataract
 391           0: cat
 392           0+ aract
 393
 394        If the pattern has the /g or /G modifier,  the  results  of  successive
 395        matching attempts are output in sequence, like this:
 396
 397            re> /\Bi(\w\w)/g
 398          data> Mississippi
 399           0: iss
 400           1: ss
 401           0: iss
 402           1: ss
 403           0: ipp
 404           1: pp
 405
 406        "No match" is output only if the first match attempt fails.
 407
 408        If  any  of the sequences \C, \G, or \L are present in a data line that
 409        is successfully matched, the substrings extracted  by  the  convenience
 410        functions are output with C, G, or L after the string number instead of
 411        a colon. This is in addition to the normal full list. The string length
 412        (that  is,  the return from the extraction function) is given in paren-
 413        theses after each string for \C and \G.
 414
 415        Note that while patterns can be continued over several lines  (a  plain
 416        ">" prompt is used for continuations), data lines may not. However new-
 417        lines can be included in data by means of the \n escape (or \r or  \r\n
 418        for those newline settings).
 419
 420
 421 OUTPUT FROM THE ALTERNATIVE MATCHING FUNCTION
 422
 423        When  the  alternative  matching function, pcre_dfa_exec(), is used (by
 424        means of the \D escape sequence or the -dfa command line  option),  the
 425        output  consists  of  a list of all the matches that start at the first
 426        point in the subject where there is at least one match. For example:
 427
 428            re> /(tang|tangerine|tan)/
 429          data> yellow tangerine\D
 430           0: tangerine
 431           1: tang
 432           2: tan
 433
 434        (Using the normal matching function on this data  finds  only  "tang".)
 435        The  longest matching string is always given first (and numbered zero).
 436
 437        If /gP is present on  the  pattern,  the  search  for  further  matches
 438        resumes at the end of the longest match. For example:
 439
 440            re> /(tang|tangerine|tan)/g
 441          data> yellow tangerine and tangy sultana\D
 442           0: tangerine
 443           1: tang
 444           2: tan
 445           0: tang
 446           1: tan
 447           0: tan
 448
 449        Since  the  matching  function  does not support substring capture, the
 450        escape sequences that are concerned with captured  substrings  are  not
 451        relevant.
 452
 453
 454 RESTARTING AFTER A PARTIAL MATCH
 455
 456        When the alternative matching function has given the PCRE_ERROR_PARTIAL
 457        return, indicating that the subject partially matched the pattern,  you
 458        can  restart  the match with additional subject data by means of the \R
 459        escape sequence. For example:
 460
 461            re> /^?(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)$/
 462          data> 23ja\P\D
 463          Partial match: 23ja
 464          data> n05\R\D
 465           0: n05
 466
 467        For further information about partial  matching,  see  the  pcrepartial
 468        documentation.
 469
 470
 471 CALLOUTS
 472
 473        If  the pattern contains any callout requests, pcretest's callout func-
 474        tion is called during matching. This works  with  both  matching  func-
 475        tions. By default, the called function displays the callout number, the
 476        start and current positions in the text at the callout  time,  and  the
 477        next pattern item to be tested. For example, the output
 478
 479          --->pqrabcdef
 480            0    ^  ^     \d
 481
 482        indicates  that  callout number 0 occurred for a match attempt starting
 483        at the fourth character of the subject string, when the pointer was  at
 484        the  seventh  character of the data, and when the next pattern item was
 485        \d. Just one circumflex is output if the start  and  current  positions
 486        are the same.
 487
 488        Callouts numbered 255 are assumed to be automatic callouts, inserted as
 489        a result of the /C pattern modifier. In this case, instead  of  showing
 490        the  callout  number, the offset in the pattern, preceded by a plus, is
 491        output. For example:
 492
 493            re> /\d?[A-E]\*/C
 494          data> E*
 495          --->E*
 496           +0 ^      \d?
 497           +3 ^      [A-E]
 498           +8 ^^     \*
 499          +10 ^ ^
 500           0: E*
 501
 502        The callout function in pcretest returns zero (carry  on  matching)  by
 503        default,  but you can use a \C item in a data line (as described above)
 504        to change this.
 505
 506        Inserting callouts can be helpful when using pcretest to check  compli-
 507        cated  regular expressions. For further information about callouts, see
 508        the pcrecallout documentation.
 509
 510
 511 SAVING AND RELOADING COMPILED PATTERNS
 512
 513        The facilities described in this section are  not  available  when  the
 514        POSIX inteface to PCRE is being used, that is, when the /P pattern mod-
 515        ifier is specified.
 516
 517        When the POSIX interface is not in use, you can cause pcretest to write
 518        a  compiled  pattern to a file, by following the modifiers with > and a
 519        file name.  For example:
 520
 521          /pattern/im >/some/file
 522
 523        See the pcreprecompile documentation for a discussion about saving  and
 524        re-using compiled patterns.
 525
 526        The  data  that  is  written  is  binary. The first eight bytes are the
 527        length of the compiled pattern data  followed  by  the  length  of  the
 528        optional  study  data,  each  written as four bytes in big-endian order
 529        (most significant byte first). If there is no study  data  (either  the
 530        pattern was not studied, or studying did not return any data), the sec-
 531        ond length is zero. The lengths are followed by an exact  copy  of  the
 532        compiled pattern. If there is additional study data, this follows imme-
 533        diately after the compiled pattern. After writing  the  file,  pcretest
 534        expects to read a new pattern.
 535
 536        A saved pattern can be reloaded into pcretest by specifing < and a file
 537        name instead of a pattern. The name of the file must not  contain  a  <
 538        character,  as  otherwise pcretest will interpret the line as a pattern
 539        delimited by < characters.  For example:
 540
 541           re> </some/file
 542          Compiled regex loaded from /some/file
 543          No study data
 544
 545        When the pattern has been loaded, pcretest proceeds to read data  lines
 546        in the usual way.
 547
 548        You  can copy a file written by pcretest to a different host and reload
 549        it there, even if the new host has opposite endianness to  the  one  on
 550        which  the pattern was compiled. For example, you can compile on an i86
 551        machine and run on a SPARC machine.
 552
 553        File names for saving and reloading can be absolute  or  relative,  but
 554        note  that the shell facility of expanding a file name that starts with
 555        a tilde (~) is not available.
 556
 557        The ability to save and reload files in pcretest is intended for  test-
 558        ing  and experimentation. It is not intended for production use because
 559        only a single pattern can be written to a file. Furthermore,  there  is
 560        no  facility  for  supplying  custom  character  tables  for use with a
 561        reloaded pattern. If the original  pattern  was  compiled  with  custom
 562        tables,  an  attempt to match a subject string using a reloaded pattern
 563        is likely to cause pcretest to crash.  Finally, if you attempt to  load
 564        a file that is not in the correct format, the result is undefined.
 565
 566
 567 AUTHOR
 568
 569        Philip Hazel
 570        University Computing Service,
 571        Cambridge CB2 3QG, England.
 572
 573 Last updated: 29 June 2006
 574 Copyright (c) 1997-2006 University of Cambridge.