Welcome to Linux Knowledge Base and Tutorial
"The place where you learn linux"
Cyber Angels

 Create an AccountHome | Submit News | Your Account  

Tutorial Menu
Linux Tutorial Home
Table of Contents

· Introduction to Operating Systems
· Linux Basics
· Working with the System
· Shells and Utilities
· Editing Files
· Basic Administration
· The Operating System
· The X Windowing System
· The Computer Itself
· Networking
· System Monitoring
· Solving Problems
· Security
· Installing and Upgrading
· Linux and Windows

Glossary
MoreInfo
Man Pages
Linux Topics
Test Your Knowledge

Site Menu
Site Map
FAQ
Copyright Info
Terms of Use
Privacy Info
Disclaimer
WorkBoard
Thanks
Donations
Advertising
Masthead / Impressum
Your Account

Communication
Feedback
Forums
Private Messages
Surveys

Features
HOWTOs
News Archive
Submit News
Topics
User Articles
Web Links

Google
Google


The Web
linux-tutorial.info

Who's Online
There are currently, 216 guest(s) and 0 member(s) that are online.

You are an Anonymous user. You can register for free by clicking here

  

pcretest




SYNOPSIS

       pcretest [-d] [-i] [-m]  [-o  osize]  [-p]  [-t]  [source]
       [destination]

       pcretest  was written as a test program for the PCRE regu­
       lar expression library itself, but it can also be used for
       experimenting  with  regular  expressions.  This  document
       describes the features of the test program; for details of
       the  regular  expressions  themselves, see the pcrepattern
       documentation. For details of PCRE and  its  options,  see
       the pcreapi documentation.


OPTIONS


       -C        Output  the  version number of the PCRE library,
                 and all available information about the optional
                 features that are included, and then exit.

       -d        Behave as if each regex had the /D modifier (see
                 below); the internal form is output after compi­
                 lation.

       -i        Behave  as  if  each  regex had the /I modifier;
                 information about the compiled pattern is  given
                 after compilation.

       -m        Output  the  size of each compiled pattern after
                 it has been  compiled.  This  is  equivalent  to
                 adding  /M  to each regular expression. For com­
                 patibility with earlier versions of pcretest, -s
                 is a synonym for -m.

       -o osize  Set  the number of elements in the output vector
                 that is used when calling PCRE to be osize.  The
                 default value is 45, which is enough for 14 cap­
                 turing subexpressions. The vector  size  can  be
                 changed for individual matching calls by includ­
                 ing \O in the data line (see below).

       -p        Behave as if each regex  has  /P  modifier;  the
                 POSIX  wrapper API is used to call PCRE. None of
                 the other options has any effect when -p is set.

       -t        Run  each  compile,  study, and match many times
                 with a timer, and output resulting time per com­
                 pile  or  match (in milliseconds). Do not set -t
                 with -m, because you will then get the size out­
                 put  20000  times  and  the  timing will be dis­
                 torted.

       and continues with any number of data lines to be  matched
       against the pattern.

       Each  line is matched separately and independently. If you
       want to do multiple-line matches, you have to use  the  \n
       escape  sequence  in  a single line of input to encode the
       newline characters. The maximum length  of  data  line  is
       30,000 characters.

       An  empty line signals the end of the data lines, at which
       point a  new  regular  expression  is  read.  The  regular
       expressions  are  given  enclosed  in  any  non-alphameric
       delimiters other than backslash, for example

         /(a|bc)x+yz/

       White space before the initial  delimiter  is  ignored.  A
       regular  expression  may  be  continued over several input
       lines, in which case the newline characters  are  included
       within  it. It is possible to include the delimiter within
       the pattern by escaping it, for example

         /abc\/def/

       If you do so, the escape and the delimiter  form  part  of
       the   pattern,   but  since  delimiters  are  always  non-
       alphameric, this does not affect its  interpretation.   If
       the  terminating  delimiter  is  immediately followed by a
       backslash, for example,

         /abc/\

       then a backslash is added to the end of the pattern.  This
       is  done  to  provide a way of testing the error condition
       that arises  if  a  pattern  finishes  with  a  backslash,
       because

         /abc\/

       is  interpreted as the first line of a pattern that starts
       with "abc/", causing pcretest to read the next line  as  a
       continuation of the regular expression.


PATTERN MODIFIERS


       The  pattern  may  be followed by i, m, s, or x to set the
       PCRE_CASELESS,     PCRE_MULTILINE,     PCRE_DOTALL,     or
       PCRE_EXTENDED options, respectively. For example:

         /caseless/i

       difference  to  the matching process if the pattern begins
       with a lookbehind assertion (including \b or \B).

       If any call to pcre_exec() in a /g or /G sequence  matches
       an   empty   string,  the  next  call  is  done  with  the
       PCRE_NOTEMPTY and PCRE_ANCHORED  flags  set  in  order  to
       search  for  another,  non-empty, match at the same point.
       If this second match fails, the start offset  is  advanced
       by one, and the normal match is retried. This imitates the
       way Perl handles such cases when using the /g modifier  or
       the split() function.

       There  are a number of other modifiers for controlling the
       way pcretest operates.

       The /+ modifier requests that as well  as  outputting  the
       substring that matched the entire pattern, pcretest should
       in addition output the remainder of  the  subject  string.
       This is useful for tests where the subject contains multi­
       ple copies of the same substring.

       The /L modifier must be followed directly by the name of a
       locale, for example,

         /pattern/Lfr

       For  this reason, it must be the last modifier letter. The
       given locale is set, pcre_maketables() is called to  build
       a set of character tables for the locale, and this is then
       passed  to  pcre_compile()  when  compiling  the   regular
       expression.  Without an /L modifier, NULL is passed as the
       tables pointer; that is, /L applies only to the expression
       on which it appears.

       The  /I modifier requests that pcretest output information
       about the compiled expression (whether it is anchored, has
       a fixed first character, and so on). It does this by call­
       ing pcre_fullinfo() after  compiling  an  expression,  and
       outputting the information it gets back. If the pattern is
       studied, the results of that are also output.

       The /D modifier is a PCRE debugging  feature,  which  also
       assumes /I.  It causes the internal form of compiled regu­
       lar expressions to be output  after  compilation.  If  the
       pattern was studied, the information returned is also out­
       put.

       The /S modifier causes pcre_study() to be called after the
       expression  has  been  compiled, and the results used when
       the expression is matched.

       The /M modifier causes the size of memory  block  used  to
       non-printing  characters  in  output strings to be printed
       using the \x{hh...}  notation  if  they  are  valid  UTF-8
       sequences.

       If  the /? modifier is used with /8, it causes pcretest to
       call pcre_compile() with the PCRE_NO_UTF8_CHECK option, to
       suppress the checking of the string for UTF-8 validity.


CALLOUTS


       If  the  pattern contains any callout requests, pcretest's
       callout function will be called. By default,  it  displays
       the callout number, and the start and current positions in
       the text at the callout time. For example, the output

         --->pqrabcdef
           0    ^  ^

       indicates that callout  number  0  occurred  for  a  match
       attempt  starting  at  the fourth character of the subject
       string, when the pointer was at the seventh character. The
       callout  function  returns  zero  (carry  on  matching) by
       default.

       Inserting callouts may be helpful when using  pcretest  to
       check  complicated regular expressions. For further infor­
       mation about callouts, see the pcrecallout  documentation.

       For  testing the PCRE library, additional control of call­
       out behaviour is available via  escape  sequences  in  the
       data,  as  described in the following section. In particu­
       lar, it is possible to pass in a number  as  callout  data
       (the  default is zero). If the callout function receives a
       non-zero number, it returns that value instead of zero.


DATA LINES


       Before each data line is passed  to  pcre_exec(),  leading
       and trailing whitespace is removed, and it is then scanned
       for \ escapes. Some of these are pretty esoteric features,
       intended  for  checking  out  some of the more complicated
       features of PCRE. If you are just testing "ordinary" regu­
       lar expressions, you probably don't need any of these. The
       following escapes are recognized:

         \a         alarm (= BEL)
         \b         backspace
         \e         escape
         \f         formfeed
         \n         newline

       string
                      "name" after a successful match (name  ter­
       min-
                      ated by next non alphanumeric character)
         \C+        show the current captured substrings at call­
       out
                      time
         \C-        do not supply a callout function
         \C!n       return 1 instead of 0 when callout  number  n
       is
                      reached
         \C!n!m      return  1 instead of 0 when callout number n
       is
                      reached for the nth time
         \C*n       pass the number n (may be negative) as  call­
       out
                      data
         \Gdd       call pcre_get_substring() for substring dd
                      after  a successful match (any decimal num­
       ber
                      less than 32)
         \Gname     call pcre_get_named_substring() for substring
                      "name"  after a successful match (name ter­
       min-
                      ated by next non-alphanumeric character)
         \L         call pcre_get_substringlist() after a
                      successful match
         \M         discover the minimum MATCH_LIMIT setting
         \N         pass the PCRE_NOTEMPTY option to pcre_exec()
         \Odd       set the size of the output vector passed to
                      pcre_exec() to dd (any number of decimal
                      digits)
         \Z         pass the PCRE_NOTEOL option to pcre_exec()
         \?         pass the PCRE_NO_UTF8_CHECK option to
                      pcre_exec()

       If \M  is  present,  pcretest  calls  pcre_exec()  several
       times,  with  different values in the match_limit field of
       the pcre_extra data structure, until it finds the  minimum
       number  that  is  needed for pcre_exec() to complete. This
       number is a measure of the amount of recursion  and  back­
       tracking  that  takes  place,  and  checking it out can be
       instructive. For most simple matches, the number is  quite
       small,  but for patterns with very large numbers of match­
       ing possibilities, it can become large very  quickly  with
       increasing length of subject string.

       When  \O  is used, it may be higher or lower than the size
       set by the -O option (or defaulted to 45); \O applies only
       to  the  call  of  pcre_exec()  for  the  line in which it
       appears.

       six bytes, encoded according to the UTF-8 rules.


OUTPUT FROM PCRETEST


       When a match succeeds, pcretest outputs the list  of  cap­
       tured  substrings  that pcre_exec() returns, starting with
       number 0 for the string that matched  the  whole  pattern.
       Here is an example of an interactive pcretest run.

         $ pcretest
         PCRE version 4.00 08-Jan-2003

           re> /^abc(\d+)/
         data> abc123
          0: abc123
          1: 123
         data> xyz
         No match

       If  the  strings contain any non-printing characters, they
       are output as \0x escapes, or as \x{...} escapes if the /8
       modifier  was  present  on the pattern. If the pattern has
       the /+ modifier, then the output for substring 0  is  fol­
       lowed by the the rest of the subject string, identified by
       "0+" like this:

           re> /cat/+
         data> cataract
          0: cat
          0+ aract

       If the pattern has the /g or /G modifier, the  results  of
       successive  matching attempts are output in sequence, like
       this:

           re> /\Bi(\w\w)/g
         data> Mississippi
          0: iss
          1: ss
          0: iss
          1: ss
          0: ipp
          1: pp

       "No match" is output  only  if  the  first  match  attempt
       fails.

       If  any  of  the  sequences \C, \G, or \L are present in a
       data line that is  successfully  matched,  the  substrings
       extracted  by the convenience functions are output with C,
       G, or L after the string number instead of a  colon.  This
       Cambridge CB2 3QG, England.

Last updated: 20 August 2003
Copyright (c) 1997-2003 University of Cambridge.

                                                      PCRETEST(1)
  
Help us cut cost by not downloading the whole site!
Use of automated download sofware ("harvesters") such as wget, httrack, etc. causes the site to quickly exceed its bandwidth limitation and therefore is expressedly prohibited. For more details on this, take a look here

Login
Nickname

Password

Security Code
Security Code
Type Security Code


Don't have an account yet? You can create one. As a registered user you have some advantages like theme manager, comments configuration and post comments with your name.

Help if you can!


Amazon Wish List

Did You Know?
The Linux Tutorial can use your help.


Friends



Tell a Friend About Us

Bookmark and Share



Web site powered by PHP-Nuke

Is this information useful? At the very least you can help by spreading the word to your favorite newsgroups, mailing lists and forums.
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters. Articles are the property of their respective owners. Unless otherwise stated in the body of the article, article content (C) 1994-2013 by James Mohr. All rights reserved. The stylized page/paper, as well as the terms "The Linux Tutorial", "The Linux Server Tutorial", "The Linux Knowledge Base and Tutorial" and "The place where you learn Linux" are service marks of James Mohr. All rights reserved.
The Linux Knowledge Base and Tutorial may contain links to sites on the Internet, which are owned and operated by third parties. The Linux Tutorial is not responsible for the content of any such third-party site. By viewing/utilizing this web site, you have agreed to our disclaimer, terms of use and privacy policy. Use of automated download software ("harvesters") such as wget, httrack, etc. causes the site to quickly exceed its bandwidth limitation and are therefore expressly prohibited. For more details on this, take a look here

PHP-Nuke Copyright © 2004 by Francisco Burzi. This is free software, and you may redistribute it under the GPL. PHP-Nuke comes with absolutely no warranty, for details, see the license.
Page Generation: 0.09 Seconds