pcretest.txt
上传用户:yhdzpy8989
上传日期:2007-06-13
资源大小:13604k
文件大小:12k
源码类别:

生物技术

开发平台:

C/C++

  1. NAME
  2.      pcretest - a program  for  testing  Perl-compatible  regular
  3.      expressions.
  4. SYNOPSIS
  5.      pcretest [-d] [-i] [-m] [-o osize] [-p] [-t] [source]  [des-
  6.      tination]
  7.      pcretest was written as a test program for the PCRE  regular
  8.      expression  library  itself,  but  it  can  also be used for
  9.      experimenting  with  regular  expressions.  This  man   page
  10.      describes  the  features of the test program; for details of
  11.      the regular expressions themselves, see the pcre man page.
  12. OPTIONS
  13.      -d        Behave as if each regex had the /D  modifier  (see
  14.                below); the internal form is output after compila-
  15.                tion.
  16.      -i        Behave as if  each  regex  had  the  /I  modifier;
  17.                information  about  the  compiled pattern is given
  18.                after compilation.
  19.      -m        Output the size of each compiled pattern after  it
  20.                has been compiled. This is equivalent to adding /M
  21.                to each regular expression. For compatibility with
  22.                earlier  versions of pcretest, -s is a synonym for
  23.                -m.
  24.      -o osize  Set the number of elements in  the  output  vector
  25.                that  is  used  when calling PCRE to be osize. The
  26.                default value is 45, which is enough for  14  cap-
  27.                turing  subexpressions.  The  vector  size  can be
  28.                changed for individual matching calls by including
  29.                O in the data line (see below).
  30.      -p        Behave as if each regex has /P modifier; the POSIX
  31.                wrapper  API  is  used  to  call PCRE. None of the
  32.                other options has any effect when -p is set.
  33.      -t        Run each compile, study,  and  match  20000  times
  34.                with  a  timer, and output resulting time per com-
  35.                pile or match (in milliseconds).  Do  not  set  -t
  36.                with -m, because you will then get the size output
  37.                20000 times and the timing will be distorted.
  38. DESCRIPTION
  39.      If pcretest is given two filename arguments, it  reads  from
  40.      the  first and writes to the second. If it is given only one
  41. SunOS 5.8                 Last change:                          1
  42.      filename argument, it reads from that  file  and  writes  to
  43.      stdout. Otherwise, it reads from stdin and writes to stdout,
  44.      and prompts for each line of input, using  "re>"  to  prompt
  45.      for  regular  expressions,  and  "data>"  to prompt for data
  46.      lines.
  47.      The program handles any number of sets of input on a  single
  48.      input  file.  Each set starts with a regular expression, and
  49.      continues with any  number  of  data  lines  to  be  matched
  50.      against  the  pattern.  An empty line signals the end of the
  51.      data lines, at which point a new regular expression is read.
  52.      The  regular  expressions  are  given  enclosed  in any non-
  53.      alphameric delimiters other than backslash, for example
  54.        /(a|bc)x+yz/
  55.      White space before the initial delimiter is ignored. A regu-
  56.      lar expression may be continued over several input lines, in
  57.      which case the newline characters are included within it. It
  58.      is  possible  to include the delimiter within the pattern by
  59.      escaping it, for example
  60.        /abc/def/
  61.      If you do so, the escape and the delimiter form part of  the
  62.      pattern,  but  since  delimiters  are always non-alphameric,
  63.      this does not affect its interpretation.  If the terminating
  64.      delimiter  is immediately followed by a backslash, for exam-
  65.      ple,
  66.        /abc/
  67.      then a backslash is added to the end of the pattern. This is
  68.      done  to  provide  a way of testing the error condition that
  69.      arises if a pattern finishes with a backslash, because
  70.        /abc/
  71.      is interpreted as the first line of a  pattern  that  starts
  72.      with  "abc/",  causing  pcretest  to read the next line as a
  73.      continuation of the regular expression.
  74. PATTERN MODIFIERS
  75.      The pattern may be followed by i, m, s,  or  x  to  set  the
  76.      PCRE_CASELESS, PCRE_MULTILINE, PCRE_DOTALL, or PCRE_EXTENDED
  77.      options, respectively. For example:
  78.        /caseless/i
  79.      These modifier letters have the same effect as  they  do  in
  80.      Perl.  There  are  others which set PCRE options that do not
  81.      correspond  to  anything  in  Perl:   /A,  /E,  and  /X  set
  82.      PCRE_ANCHORED,  PCRE_DOLLAR_ENDONLY,  and PCRE_EXTRA respec-
  83.      tively.
  84.      Searching for  all  possible  matches  within  each  subject
  85.      string  can  be  requested  by  the /g or /G modifier. After
  86.      finding  a  match,  PCRE  is  called  again  to  search  the
  87.      remainder  of  the subject string. The difference between /g
  88.      and /G is that the former uses the startoffset  argument  to
  89.      pcre_exec()  to  start  searching  at a new point within the
  90.      entire string (which is in effect what Perl  does),  whereas
  91.      the  latter  passes over a shortened substring. This makes a
  92.      difference to the matching process  if  the  pattern  begins
  93.      with a lookbehind assertion (including b or B).
  94.      If any call to pcre_exec() in a /g or /G sequence matches an
  95.      empty  string,  the next call is done with the PCRE_NOTEMPTY
  96.      and PCRE_ANCHORED flags set in order to search for  another,
  97.      non-empty,  match  at  the same point.  If this second match
  98.      fails, the start offset is advanced by one, and  the  normal
  99.      match  is  retried.  This imitates the way Perl handles such
  100.      cases when using the /g modifier or the split() function.
  101.      There are a number of other modifiers  for  controlling  the
  102.      way pcretest operates.
  103.      The /+ modifier requests that as well as outputting the sub-
  104.      string  that  matched the entire pattern, pcretest should in
  105.      addition output the remainder of the subject string. This is
  106.      useful  for tests where the subject contains multiple copies
  107.      of the same substring.
  108.      The /L modifier must be followed directly by the name  of  a
  109.      locale, for example,
  110.        /pattern/Lfr
  111.      For this reason, it must be the last  modifier  letter.  The
  112.      given  locale is set, pcre_maketables() is called to build a
  113.      set of character tables for the locale,  and  this  is  then
  114.      passed  to pcre_compile() when compiling the regular expres-
  115.      sion. Without an /L modifier, NULL is passed as  the  tables
  116.      pointer; that is, /L applies only to the expression on which
  117.      it appears.
  118.      The /I modifier requests that  pcretest  output  information
  119.      about the compiled expression (whether it is anchored, has a
  120.      fixed first character, and so on). It does this  by  calling
  121.      pcre_fullinfo()  after  compiling an expression, and output-
  122.      ting the information it gets back. If the  pattern  is  stu-
  123.      died, the results of that are also output.
  124.      The /D modifier is a  PCRE  debugging  feature,  which  also
  125.      assumes /I.  It causes the internal form of compiled regular
  126.      expressions to be output after compilation.
  127.      The /S modifier causes pcre_study() to be called  after  the
  128.      expression  has been compiled, and the results used when the
  129.      expression is matched.
  130.      The /M modifier causes the size of memory block used to hold
  131.      the compiled pattern to be output.
  132.      The /P modifier causes pcretest to call PCRE via  the  POSIX
  133.      wrapper  API  rather than its native API. When this is done,
  134.      all other modifiers except  /i,  /m,  and  /+  are  ignored.
  135.      REG_ICASE is set if /i is present, and REG_NEWLINE is set if
  136.      /m    is    present.    The    wrapper    functions    force
  137.      PCRE_DOLLAR_ENDONLY    always,    and   PCRE_DOTALL   unless
  138.      REG_NEWLINE is set.
  139.      The /8 modifier  causes  pcretest  to  call  PCRE  with  the
  140.      PCRE_UTF8  option  set.  This turns on the (currently incom-
  141.      plete) support for UTF-8 character handling  in  PCRE,  pro-
  142.      vided  that  it was compiled with this support enabled. This
  143.      modifier also causes any non-printing characters  in  output
  144.      strings  to  be printed using the x{hh...} notation if they
  145.      are valid UTF-8 sequences.
  146. DATA LINES
  147.      Before each data line is passed to pcre_exec(), leading  and
  148.      trailing whitespace is removed, and it is then scanned for 
  149.      escapes. The following are recognized:
  150.        a         alarm (= BEL)
  151.        b         backspace
  152.        e         escape
  153.        f         formfeed
  154.        n         newline
  155.        r         carriage return
  156.        t         tab
  157.        v         vertical tab
  158.        nnn       octal character (up to 3 octal digits)
  159.        xhh       hexadecimal character (up to 2 hex digits)
  160.        x{hh...}  hexadecimal UTF-8 character
  161.        A         pass the PCRE_ANCHORED option to pcre_exec()
  162.        B         pass the PCRE_NOTBOL option to pcre_exec()
  163.        Cdd       call pcre_copy_substring() for substring dd
  164.                      after a successful match (any decimal number
  165.                      less than 32)
  166.        Gdd       call pcre_get_substring() for substring dd
  167.                      after a successful match (any decimal number
  168.                      less than 32)
  169.        L         call pcre_get_substringlist() after a
  170.                      successful match
  171.        N         pass the PCRE_NOTEMPTY option to pcre_exec()
  172.        Odd       set the size of the output vector passed to
  173.                      pcre_exec() to dd (any number of decimal
  174.                      digits)
  175.        Z         pass the PCRE_NOTEOL option to pcre_exec()
  176.      When O is used, it may be higher or lower than the size set
  177.      by  the  -O  option (or defaulted to 45); O applies only to
  178.      the call of pcre_exec() for the line in which it appears.
  179.      A backslash followed by anything else just escapes the  any-
  180.      thing else. If the very last character is a backslash, it is
  181.      ignored. This gives a way of passing an empty line as  data,
  182.      since a real empty line terminates the data input.
  183.      If /P was present on the regex, causing  the  POSIX  wrapper
  184.      API  to  be  used,  only  B,  and Z have any effect, causing
  185.      REG_NOTBOL and REG_NOTEOL to be passed to regexec()  respec-
  186.      tively.
  187.      The use of x{hh...} to represent UTF-8  characters  is  not
  188.      dependent  on  the use of the /8 modifier on the pattern. It
  189.      is recognized always. There may be any number of hexadecimal
  190.      digits  inside  the  braces.  The  result is from one to six
  191.      bytes, encoded according to the UTF-8 rules.
  192. OUTPUT FROM PCRETEST
  193.      When a match succeeds, pcretest outputs the list of captured
  194.      substrings  that pcre_exec() returns, starting with number 0
  195.      for the string that matched the whole pattern.  Here  is  an
  196.      example of an interactive pcretest run.
  197.        $ pcretest
  198.        PCRE version 2.06 08-Jun-1999
  199.          re> /^abc(d+)/
  200.        data> abc123
  201.         0: abc123
  202.         1: 123
  203.        data> xyz
  204.        No match
  205.      If the strings contain any non-printing characters, they are
  206.      output  as  x  escapes,  or  as  x{...} escapes if the /8
  207.      modifier was present on the pattern. If the pattern has  the
  208.      /+  modifier, then the output for substring 0 is followed by
  209.      the the rest of the subject string, identified by "0+"  like
  210.      this:
  211.          re> /cat/+
  212.        data> cataract
  213.         0: cat
  214.         0+ aract
  215.      If the pattern has the /g or /G  modifier,  the  results  of
  216.      successive  matching  attempts  are output in sequence, like
  217.      this:
  218.          re> /Bi(ww)/g
  219.        data> Mississippi
  220.         0: iss
  221.         1: ss
  222.         0: iss
  223.         1: ss
  224.         0: ipp
  225.         1: pp
  226.      "No match" is output only if the first match attempt fails.
  227.      If any of the sequences C, G, or L are present in a  data
  228.      line  that is successfully matched, the substrings extracted
  229.      by the convenience functions are output  with  C,  G,  or  L
  230.      after the string number instead of a colon. This is in addi-
  231.      tion to the normal full list. The string  length  (that  is,
  232.      the  return  from  the  extraction  function)  is  given  in
  233.      parentheses after each string for C and G.
  234.      Note that while patterns can be continued over several lines
  235.      (a  plain  ">" prompt is used for continuations), data lines
  236.      may not. However newlines can be included in data  by  means
  237.      of the n escape.
  238. AUTHOR
  239.      Philip Hazel <ph10@cam.ac.uk>
  240.      University Computing Service,
  241.      New Museums Site,
  242.      Cambridge CB2 3QG, England.
  243.      Phone: +44 1223 334714
  244.      Last updated: 15 August 2001
  245.      Copyright (c) 1997-2001 University of Cambridge.