RubyGems - esruby - Versions diffs - 0.0.0 → 0.0.2 - Mend

esruby 0.0.0 → 0.0.2

Files changed (385) hide show

data/resources/mruby/build/mrbgems/mruby-regexp-pcre/pcre/doc/html/pcrecpp.html DELETED Viewed

@@ -1,368 +0,0 @@
-<html>
-<head>
-<title>pcrecpp specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcrecpp man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<ul>
-<li><a name="TOC1" href="#SEC1">SYNOPSIS OF C++ WRAPPER</a>
-<li><a name="TOC2" href="#SEC2">DESCRIPTION</a>
-<li><a name="TOC3" href="#SEC3">MATCHING INTERFACE</a>
-<li><a name="TOC4" href="#SEC4">QUOTING METACHARACTERS</a>
-<li><a name="TOC5" href="#SEC5">PARTIAL MATCHES</a>
-<li><a name="TOC6" href="#SEC6">UTF-8 AND THE MATCHING INTERFACE</a>
-<li><a name="TOC7" href="#SEC7">PASSING MODIFIERS TO THE REGULAR EXPRESSION ENGINE</a>
-<li><a name="TOC8" href="#SEC8">SCANNING TEXT INCREMENTALLY</a>
-<li><a name="TOC9" href="#SEC9">PARSING HEX/OCTAL/C-RADIX NUMBERS</a>
-<li><a name="TOC10" href="#SEC10">REPLACING PARTS OF STRINGS</a>
-<li><a name="TOC11" href="#SEC11">AUTHOR</a>
-<li><a name="TOC12" href="#SEC12">REVISION</a>
-</ul>
-<br><a name="SEC1" href="#TOC1">SYNOPSIS OF C++ WRAPPER</a><br>
-<P>
-<b>#include &#60;pcrecpp.h&#62;</b>
-</P>
-<br><a name="SEC2" href="#TOC1">DESCRIPTION</a><br>
-<P>
-The C++ wrapper for PCRE was provided by Google Inc. Some additional
-functionality was added by Giuseppe Maxia. This brief man page was constructed
-from the notes in the <i>pcrecpp.h</i> file, which should be consulted for
-further details. Note that the C++ wrapper supports only the original 8-bit
-PCRE library. There is no 16-bit or 32-bit support at present.
-</P>
-<br><a name="SEC3" href="#TOC1">MATCHING INTERFACE</a><br>
-<P>
-The "FullMatch" operation checks that supplied text matches a supplied pattern
-exactly. If pointer arguments are supplied, it copies matched sub-strings that
-match sub-patterns into them.
-<pre>
-  Example: successful match
-     pcrecpp::RE re("h.*o");
-     re.FullMatch("hello");
-  Example: unsuccessful match (requires full match):
-     pcrecpp::RE re("e");
-     !re.FullMatch("hello");
-  Example: creating a temporary RE object:
-     pcrecpp::RE("h.*o").FullMatch("hello");
-</pre>
-You can pass in a "const char*" or a "string" for "text". The examples below
-tend to use a const char*. You can, as in the different examples above, store
-the RE object explicitly in a variable or use a temporary RE object. The
-examples below use one mode or the other arbitrarily. Either could correctly be
-used for any of these examples.
-</P>
-<P>
-You must supply extra pointer arguments to extract matched subpieces.
-<pre>
-  Example: extracts "ruby" into "s" and 1234 into "i"
-     int i;
-     string s;
-     pcrecpp::RE re("(\\w+):(\\d+)");
-     re.FullMatch("ruby:1234", &s, &i);
-  Example: does not try to extract any extra sub-patterns
-     re.FullMatch("ruby:1234", &s);
-  Example: does not try to extract into NULL
-     re.FullMatch("ruby:1234", NULL, &i);
-  Example: integer overflow causes failure
-     !re.FullMatch("ruby:1234567891234", NULL, &i);
-  Example: fails because there aren't enough sub-patterns:
-     !pcrecpp::RE("\\w+:\\d+").FullMatch("ruby:1234", &s);
-  Example: fails because string cannot be stored in integer
-     !pcrecpp::RE("(.*)").FullMatch("ruby", &i);
-</pre>
-The provided pointer arguments can be pointers to any scalar numeric
-type, or one of:
-<pre>
-   string        (matched piece is copied to string)
-   StringPiece   (StringPiece is mutated to point to matched piece)
-   T             (where "bool T::ParseFrom(const char*, int)" exists)
-   NULL          (the corresponding matched sub-pattern is not copied)
-</pre>
-The function returns true iff all of the following conditions are satisfied:
-<pre>
-  a. "text" matches "pattern" exactly;
-  b. The number of matched sub-patterns is &#62;= number of supplied
-     pointers;
-  c. The "i"th argument has a suitable type for holding the
-     string captured as the "i"th sub-pattern. If you pass in
-     void * NULL for the "i"th argument, or a non-void * NULL
-     of the correct type, or pass fewer arguments than the
-     number of sub-patterns, "i"th captured sub-pattern is
-     ignored.
-</pre>
-CAVEAT: An optional sub-pattern that does not exist in the matched
-string is assigned the empty string. Therefore, the following will
-return false (because the empty string is not a valid number):
-<pre>
-   int number;
-   pcrecpp::RE::FullMatch("abc", "[a-z]+(\\d+)?", &number);
-</pre>
-The matching interface supports at most 16 arguments per call.
-If you need more, consider using the more general interface
-<b>pcrecpp::RE::DoMatch</b>. See <b>pcrecpp.h</b> for the signature for
-<b>DoMatch</b>.
-</P>
-<P>
-NOTE: Do not use <b>no_arg</b>, which is used internally to mark the end of a
-list of optional arguments, as a placeholder for missing arguments, as this can
-lead to segfaults.
-</P>
-<br><a name="SEC4" href="#TOC1">QUOTING METACHARACTERS</a><br>
-<P>
-You can use the "QuoteMeta" operation to insert backslashes before all
-potentially meaningful characters in a string. The returned string, used as a
-regular expression, will exactly match the original string.
-<pre>
-  Example:
-     string quoted = RE::QuoteMeta(unquoted);
-</pre>
-Note that it's legal to escape a character even if it has no special meaning in
-a regular expression -- so this function does that. (This also makes it
-identical to the perl function of the same name; see "perldoc -f quotemeta".)
-For example, "1.5-2.0?" becomes "1\.5\-2\.0\?".
-</P>
-<br><a name="SEC5" href="#TOC1">PARTIAL MATCHES</a><br>
-<P>
-You can use the "PartialMatch" operation when you want the pattern
-to match any substring of the text.
-<pre>
-  Example: simple search for a string:
-     pcrecpp::RE("ell").PartialMatch("hello");
-  Example: find first number in a string:
-     int number;
-     pcrecpp::RE re("(\\d+)");
-     re.PartialMatch("x*100 + 20", &number);
-     assert(number == 100);
-</PRE>
-</P>
-<br><a name="SEC6" href="#TOC1">UTF-8 AND THE MATCHING INTERFACE</a><br>
-<P>
-By default, pattern and text are plain text, one byte per character. The UTF8
-flag, passed to the constructor, causes both pattern and string to be treated
-as UTF-8 text, still a byte stream but potentially multiple bytes per
-character. In practice, the text is likelier to be UTF-8 than the pattern, but
-the match returned may depend on the UTF8 flag, so always use it when matching
-UTF8 text. For example, "." will match one byte normally but with UTF8 set may
-match up to three bytes of a multi-byte character.
-<pre>
-  Example:
-     pcrecpp::RE_Options options;
-     options.set_utf8();
-     pcrecpp::RE re(utf8_pattern, options);
-     re.FullMatch(utf8_string);
-  Example: using the convenience function UTF8():
-     pcrecpp::RE re(utf8_pattern, pcrecpp::UTF8());
-     re.FullMatch(utf8_string);
-</pre>
-NOTE: The UTF8 flag is ignored if pcre was not configured with the
-<pre>
-      --enable-utf8 flag.
-</PRE>
-</P>
-<br><a name="SEC7" href="#TOC1">PASSING MODIFIERS TO THE REGULAR EXPRESSION ENGINE</a><br>
-<P>
-PCRE defines some modifiers to change the behavior of the regular expression
-engine. The C++ wrapper defines an auxiliary class, RE_Options, as a vehicle to
-pass such modifiers to a RE class. Currently, the following modifiers are
-supported:
-<pre>
-   modifier              description               Perl corresponding
-   PCRE_CASELESS         case insensitive match      /i
-   PCRE_MULTILINE        multiple lines match        /m
-   PCRE_DOTALL           dot matches newlines        /s
-   PCRE_DOLLAR_ENDONLY   $ matches only at end       N/A
-   PCRE_EXTRA            strict escape parsing       N/A
-   PCRE_EXTENDED         ignore white spaces         /x
-   PCRE_UTF8             handles UTF8 chars          built-in
-   PCRE_UNGREEDY         reverses * and *?           N/A
-   PCRE_NO_AUTO_CAPTURE  disables capturing parens   N/A (*)
-</pre>
-(*) Both Perl and PCRE allow non capturing parentheses by means of the
-"?:" modifier within the pattern itself. e.g. (?:ab|cd) does not
-capture, while (ab|cd) does.
-</P>
-<P>
-For a full account on how each modifier works, please check the
-PCRE API reference page.
-</P>
-<P>
-For each modifier, there are two member functions whose name is made
-out of the modifier in lowercase, without the "PCRE_" prefix. For
-instance, PCRE_CASELESS is handled by
-<pre>
-  bool caseless()
-</pre>
-which returns true if the modifier is set, and
-<pre>
-  RE_Options & set_caseless(bool)
-</pre>
-which sets or unsets the modifier. Moreover, PCRE_EXTRA_MATCH_LIMIT can be
-accessed through the <b>set_match_limit()</b> and <b>match_limit()</b> member
-functions. Setting <i>match_limit</i> to a non-zero value will limit the
-execution of pcre to keep it from doing bad things like blowing the stack or
-taking an eternity to return a result. A value of 5000 is good enough to stop
-stack blowup in a 2MB thread stack. Setting <i>match_limit</i> to zero disables
-match limiting. Alternatively, you can call <b>match_limit_recursion()</b>
-which uses PCRE_EXTRA_MATCH_LIMIT_RECURSION to limit how much PCRE
-recurses. <b>match_limit()</b> limits the number of matches PCRE does;
-<b>match_limit_recursion()</b> limits the depth of internal recursion, and
-therefore the amount of stack that is used.
-</P>
-<P>
-Normally, to pass one or more modifiers to a RE class, you declare
-a <i>RE_Options</i> object, set the appropriate options, and pass this
-object to a RE constructor. Example:
-<pre>
-   RE_Options opt;
-   opt.set_caseless(true);
-   if (RE("HELLO", opt).PartialMatch("hello world")) ...
-</pre>
-RE_options has two constructors. The default constructor takes no arguments and
-creates a set of flags that are off by default. The optional parameter
-<i>option_flags</i> is to facilitate transfer of legacy code from C programs.
-This lets you do
-<pre>
-   RE(pattern,
-     RE_Options(PCRE_CASELESS|PCRE_MULTILINE)).PartialMatch(str);
-</pre>
-However, new code is better off doing
-<pre>
-   RE(pattern,
-     RE_Options().set_caseless(true).set_multiline(true))
-       .PartialMatch(str);
-</pre>
-If you are going to pass one of the most used modifiers, there are some
-convenience functions that return a RE_Options class with the
-appropriate modifier already set: <b>CASELESS()</b>, <b>UTF8()</b>,
-<b>MULTILINE()</b>, <b>DOTALL</b>(), and <b>EXTENDED()</b>.
-</P>
-<P>
-If you need to set several options at once, and you don't want to go through
-the pains of declaring a RE_Options object and setting several options, there
-is a parallel method that give you such ability on the fly. You can concatenate
-several <b>set_xxxxx()</b> member functions, since each of them returns a
-reference to its class object. For example, to pass PCRE_CASELESS,
-PCRE_EXTENDED, and PCRE_MULTILINE to a RE with one statement, you may write:
-<pre>
-   RE(" ^ xyz \\s+ .* blah$",
-     RE_Options()
-       .set_caseless(true)
-       .set_extended(true)
-       .set_multiline(true)).PartialMatch(sometext);
-</PRE>
-</P>
-<br><a name="SEC8" href="#TOC1">SCANNING TEXT INCREMENTALLY</a><br>
-<P>
-The "Consume" operation may be useful if you want to repeatedly
-match regular expressions at the front of a string and skip over
-them as they match. This requires use of the "StringPiece" type,
-which represents a sub-range of a real string. Like RE, StringPiece
-is defined in the pcrecpp namespace.
-<pre>
-  Example: read lines of the form "var = value" from a string.
-     string contents = ...;                 // Fill string somehow
-     pcrecpp::StringPiece input(contents);  // Wrap in a StringPiece
-     string var;
-     int value;
-     pcrecpp::RE re("(\\w+) = (\\d+)\n");
-     while (re.Consume(&input, &var, &value)) {
-       ...;
-     }
-</pre>
-Each successful call to "Consume" will set "var/value", and also
-advance "input" so it points past the matched text.
-</P>
-<P>
-The "FindAndConsume" operation is similar to "Consume" but does not
-anchor your match at the beginning of the string. For example, you
-could extract all words from a string by repeatedly calling
-<pre>
-  pcrecpp::RE("(\\w+)").FindAndConsume(&input, &word)
-</PRE>
-</P>
-<br><a name="SEC9" href="#TOC1">PARSING HEX/OCTAL/C-RADIX NUMBERS</a><br>
-<P>
-By default, if you pass a pointer to a numeric value, the
-corresponding text is interpreted as a base-10 number. You can
-instead wrap the pointer with a call to one of the operators Hex(),
-Octal(), or CRadix() to interpret the text in another base. The
-CRadix operator interprets C-style "0" (base-8) and "0x" (base-16)
-prefixes, but defaults to base-10.
-<pre>
-  Example:
-    int a, b, c, d;
-    pcrecpp::RE re("(.*) (.*) (.*) (.*)");
-    re.FullMatch("100 40 0100 0x40",
-                 pcrecpp::Octal(&a), pcrecpp::Hex(&b),
-                 pcrecpp::CRadix(&c), pcrecpp::CRadix(&d));
-</pre>
-will leave 64 in a, b, c, and d.
-</P>
-<br><a name="SEC10" href="#TOC1">REPLACING PARTS OF STRINGS</a><br>
-<P>
-You can replace the first match of "pattern" in "str" with "rewrite".
-Within "rewrite", backslash-escaped digits (\1 to \9) can be
-used to insert text matching corresponding parenthesized group
-from the pattern. \0 in "rewrite" refers to the entire matching
-text. For example:
-<pre>
-  string s = "yabba dabba doo";
-  pcrecpp::RE("b+").Replace("d", &s);
-</pre>
-will leave "s" containing "yada dabba doo". The result is true if the pattern
-matches and a replacement occurs, false otherwise.
-</P>
-<P>
-<b>GlobalReplace</b> is like <b>Replace</b> except that it replaces all
-occurrences of the pattern in the string with the rewrite. Replacements are
-not subject to re-matching. For example:
-<pre>
-  string s = "yabba dabba doo";
-  pcrecpp::RE("b+").GlobalReplace("d", &s);
-</pre>
-will leave "s" containing "yada dada doo". It returns the number of
-replacements made.
-</P>
-<P>
-<b>Extract</b> is like <b>Replace</b>, except that if the pattern matches,
-"rewrite" is copied into "out" (an additional argument) with substitutions.
-The non-matching portions of "text" are ignored. Returns true iff a match
-occurred and the extraction happened successfully;  if no match occurs, the
-string is left unaffected.
-</P>
-<br><a name="SEC11" href="#TOC1">AUTHOR</a><br>
-<P>
-The C++ wrapper was contributed by Google Inc.
-<br>
-Copyright &copy; 2007 Google Inc.
-<br>
-</P>
-<br><a name="SEC12" href="#TOC1">REVISION</a><br>
-<P>
-Last updated: 08 January 2012
-<br>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>

data/resources/mruby/build/mrbgems/mruby-regexp-pcre/pcre/doc/html/pcredemo.html DELETED Viewed

@@ -1,426 +0,0 @@
-<html>
-<head>
-<title>pcredemo specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcredemo man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<ul>
-</ul>
-<PRE>
-/*************************************************
-*           PCRE DEMONSTRATION PROGRAM           *
-*************************************************/
-/* This is a demonstration program to illustrate the most straightforward ways
-of calling the PCRE regular expression library from a C program. See the
-pcresample documentation for a short discussion ("man pcresample" if you have
-the PCRE man pages installed).
-In Unix-like environments, if PCRE is installed in your standard system
-libraries, you should be able to compile this program using this command:
-gcc -Wall pcredemo.c -lpcre -o pcredemo
-If PCRE is not installed in a standard place, it is likely to be installed with
-support for the pkg-config mechanism. If you have pkg-config, you can compile
-this program using this command:
-gcc -Wall pcredemo.c `pkg-config --cflags --libs libpcre` -o pcredemo
-If you do not have pkg-config, you may have to use this:
-gcc -Wall pcredemo.c -I/usr/local/include -L/usr/local/lib \
-  -R/usr/local/lib -lpcre -o pcredemo
-Replace "/usr/local/include" and "/usr/local/lib" with wherever the include and
-library files for PCRE are installed on your system. Only some operating
-systems (e.g. Solaris) use the -R option.
-Building under Windows:
-If you want to statically link this program against a non-dll .a file, you must
-define PCRE_STATIC before including pcre.h, otherwise the pcre_malloc() and
-pcre_free() exported functions will be declared __declspec(dllimport), with
-unwanted results. So in this environment, uncomment the following line. */
-/* #define PCRE_STATIC */
-#include &lt;stdio.h&gt;
-#include &lt;string.h&gt;
-#include &lt;pcre.h&gt;
-#define OVECCOUNT 30    /* should be a multiple of 3 */
-int main(int argc, char **argv)
-{
-pcre *re;
-const char *error;
-char *pattern;
-char *subject;
-unsigned char *name_table;
-unsigned int option_bits;
-int erroffset;
-int find_all;
-int crlf_is_newline;
-int namecount;
-int name_entry_size;
-int ovector[OVECCOUNT];
-int subject_length;
-int rc, i;
-int utf8;
-/**************************************************************************
-* First, sort out the command line. There is only one possible option at  *
-* the moment, "-g" to request repeated matching to find all occurrences,  *
-* like Perl's /g option. We set the variable find_all to a non-zero value *
-* if the -g option is present. Apart from that, there must be exactly two *
-* arguments.                                                              *
-**************************************************************************/
-find_all = 0;
-for (i = 1; i &lt; argc; i++)
-  {
-  if (strcmp(argv[i], "-g") == 0) find_all = 1;
-    else break;
-  }
-/* After the options, we require exactly two arguments, which are the pattern,
-and the subject string. */
-if (argc - i != 2)
-  {
-  printf("Two arguments required: a regex and a subject string\n");
-  return 1;
-  }
-pattern = argv[i];
-subject = argv[i+1];
-subject_length = (int)strlen(subject);
-/*************************************************************************
-* Now we are going to compile the regular expression pattern, and handle *
-* and errors that are detected.                                          *
-*************************************************************************/
-re = pcre_compile(
-  pattern,              /* the pattern */
-  0,                    /* default options */
-  &amp;error,               /* for error message */
-  &amp;erroffset,           /* for error offset */
-  NULL);                /* use default character tables */
-/* Compilation failed: print the error message and exit */
-if (re == NULL)
-  {
-  printf("PCRE compilation failed at offset %d: %s\n", erroffset, error);
-  return 1;
-  }
-/*************************************************************************
-* If the compilation succeeded, we call PCRE again, in order to do a     *
-* pattern match against the subject string. This does just ONE match. If *
-* further matching is needed, it will be done below.                     *
-*************************************************************************/
-rc = pcre_exec(
-  re,                   /* the compiled pattern */
-  NULL,                 /* no extra data - we didn't study the pattern */
-  subject,              /* the subject string */
-  subject_length,       /* the length of the subject */
-  0,                    /* start at offset 0 in the subject */
-  0,                    /* default options */
-  ovector,              /* output vector for substring information */
-  OVECCOUNT);           /* number of elements in the output vector */
-/* Matching failed: handle error cases */
-if (rc &lt; 0)
-  {
-  switch(rc)
-    {
-    case PCRE_ERROR_NOMATCH: printf("No match\n"); break;
-    /*
-    Handle other special cases if you like
-    */
-    default: printf("Matching error %d\n", rc); break;
-    }
-  pcre_free(re);     /* Release memory used for the compiled pattern */
-  return 1;
-  }
-/* Match succeded */
-printf("\nMatch succeeded at offset %d\n", ovector[0]);
-/*************************************************************************
-* We have found the first match within the subject string. If the output *
-* vector wasn't big enough, say so. Then output any substrings that were *
-* captured.                                                              *
-*************************************************************************/
-/* The output vector wasn't big enough */
-if (rc == 0)
-  {
-  rc = OVECCOUNT/3;
-  printf("ovector only has room for %d captured substrings\n", rc - 1);
-  }
-/* Show substrings stored in the output vector by number. Obviously, in a real
-application you might want to do things other than print them. */
-for (i = 0; i &lt; rc; i++)
-  {
-  char *substring_start = subject + ovector[2*i];
-  int substring_length = ovector[2*i+1] - ovector[2*i];
-  printf("%2d: %.*s\n", i, substring_length, substring_start);
-  }
-/**************************************************************************
-* That concludes the basic part of this demonstration program. We have    *
-* compiled a pattern, and performed a single match. The code that follows *
-* shows first how to access named substrings, and then how to code for    *
-* repeated matches on the same subject.                                   *
-**************************************************************************/
-/* See if there are any named substrings, and if so, show them by name. First
-we have to extract the count of named parentheses from the pattern. */
-(void)pcre_fullinfo(
-  re,                   /* the compiled pattern */
-  NULL,                 /* no extra data - we didn't study the pattern */
-  PCRE_INFO_NAMECOUNT,  /* number of named substrings */
-  &amp;namecount);          /* where to put the answer */
-if (namecount &lt;= 0) printf("No named substrings\n"); else
-  {
-  unsigned char *tabptr;
-  printf("Named substrings\n");
-  /* Before we can access the substrings, we must extract the table for
-  translating names to numbers, and the size of each entry in the table. */
-  (void)pcre_fullinfo(
-    re,                       /* the compiled pattern */
-    NULL,                     /* no extra data - we didn't study the pattern */
-    PCRE_INFO_NAMETABLE,      /* address of the table */
-    &amp;name_table);             /* where to put the answer */
-  (void)pcre_fullinfo(
-    re,                       /* the compiled pattern */
-    NULL,                     /* no extra data - we didn't study the pattern */
-    PCRE_INFO_NAMEENTRYSIZE,  /* size of each entry in the table */
-    &amp;name_entry_size);        /* where to put the answer */
-  /* Now we can scan the table and, for each entry, print the number, the name,
-  and the substring itself. */
-  tabptr = name_table;
-  for (i = 0; i &lt; namecount; i++)
-    {
-    int n = (tabptr[0] &lt;&lt; 8) | tabptr[1];
-    printf("(%d) %*s: %.*s\n", n, name_entry_size - 3, tabptr + 2,
-      ovector[2*n+1] - ovector[2*n], subject + ovector[2*n]);
-    tabptr += name_entry_size;
-    }
-  }
-/*************************************************************************
-* If the "-g" option was given on the command line, we want to continue  *
-* to search for additional matches in the subject string, in a similar   *
-* way to the /g option in Perl. This turns out to be trickier than you   *
-* might think because of the possibility of matching an empty string.    *
-* What happens is as follows:                                            *
-*                                                                        *
-* If the previous match was NOT for an empty string, we can just start   *
-* the next match at the end of the previous one.                         *
-*                                                                        *
-* If the previous match WAS for an empty string, we can't do that, as it *
-* would lead to an infinite loop. Instead, a special call of pcre_exec() *
-* is made with the PCRE_NOTEMPTY_ATSTART and PCRE_ANCHORED flags set.    *
-* The first of these tells PCRE that an empty string at the start of the *
-* subject is not a valid match; other possibilities must be tried. The   *
-* second flag restricts PCRE to one match attempt at the initial string  *
-* position. If this match succeeds, an alternative to the empty string   *
-* match has been found, and we can print it and proceed round the loop,  *
-* advancing by the length of whatever was found. If this match does not  *
-* succeed, we still stay in the loop, advancing by just one character.   *
-* In UTF-8 mode, which can be set by (*UTF8) in the pattern, this may be *
-* more than one byte.                                                    *
-*                                                                        *
-* However, there is a complication concerned with newlines. When the     *
-* newline convention is such that CRLF is a valid newline, we must       *
-* advance by two characters rather than one. The newline convention can  *
-* be set in the regex by (*CR), etc.; if not, we must find the default.  *
-*************************************************************************/
-if (!find_all)     /* Check for -g */
-  {
-  pcre_free(re);   /* Release the memory used for the compiled pattern */
-  return 0;        /* Finish unless -g was given */
-  }
-/* Before running the loop, check for UTF-8 and whether CRLF is a valid newline
-sequence. First, find the options with which the regex was compiled; extract
-the UTF-8 state, and mask off all but the newline options. */
-(void)pcre_fullinfo(re, NULL, PCRE_INFO_OPTIONS, &amp;option_bits);
-utf8 = option_bits &amp; PCRE_UTF8;
-option_bits &amp;= PCRE_NEWLINE_CR|PCRE_NEWLINE_LF|PCRE_NEWLINE_CRLF|
-               PCRE_NEWLINE_ANY|PCRE_NEWLINE_ANYCRLF;
-/* If no newline options were set, find the default newline convention from the
-build configuration. */
-if (option_bits == 0)
-  {
-  int d;
-  (void)pcre_config(PCRE_CONFIG_NEWLINE, &amp;d);
-  /* Note that these values are always the ASCII ones, even in
-  EBCDIC environments. CR = 13, NL = 10. */
-  option_bits = (d == 13)? PCRE_NEWLINE_CR :
-          (d == 10)? PCRE_NEWLINE_LF :
-          (d == (13&lt;&lt;8 | 10))? PCRE_NEWLINE_CRLF :
-          (d == -2)? PCRE_NEWLINE_ANYCRLF :
-          (d == -1)? PCRE_NEWLINE_ANY : 0;
-  }
-/* See if CRLF is a valid newline sequence. */
-crlf_is_newline =
-     option_bits == PCRE_NEWLINE_ANY ||
-     option_bits == PCRE_NEWLINE_CRLF ||
-     option_bits == PCRE_NEWLINE_ANYCRLF;
-/* Loop for second and subsequent matches */
-for (;;)
-  {
-  int options = 0;                 /* Normally no options */
-  int start_offset = ovector[1];   /* Start at end of previous match */
-  /* If the previous match was for an empty string, we are finished if we are
-  at the end of the subject. Otherwise, arrange to run another match at the
-  same point to see if a non-empty match can be found. */
-  if (ovector[0] == ovector[1])
-    {
-    if (ovector[0] == subject_length) break;
-    options = PCRE_NOTEMPTY_ATSTART | PCRE_ANCHORED;
-    }
-  /* Run the next matching operation */
-  rc = pcre_exec(
-    re,                   /* the compiled pattern */
-    NULL,                 /* no extra data - we didn't study the pattern */
-    subject,              /* the subject string */
-    subject_length,       /* the length of the subject */
-    start_offset,         /* starting offset in the subject */
-    options,              /* options */
-    ovector,              /* output vector for substring information */
-    OVECCOUNT);           /* number of elements in the output vector */
-  /* This time, a result of NOMATCH isn't an error. If the value in "options"
-  is zero, it just means we have found all possible matches, so the loop ends.
-  Otherwise, it means we have failed to find a non-empty-string match at a
-  point where there was a previous empty-string match. In this case, we do what
-  Perl does: advance the matching position by one character, and continue. We
-  do this by setting the "end of previous match" offset, because that is picked
-  up at the top of the loop as the point at which to start again.
-  There are two complications: (a) When CRLF is a valid newline sequence, and
-  the current position is just before it, advance by an extra byte. (b)
-  Otherwise we must ensure that we skip an entire UTF-8 character if we are in
-  UTF-8 mode. */
-  if (rc == PCRE_ERROR_NOMATCH)
-    {
-    if (options == 0) break;                    /* All matches found */
-    ovector[1] = start_offset + 1;              /* Advance one byte */
-    if (crlf_is_newline &amp;&amp;                      /* If CRLF is newline &amp; */
-        start_offset &lt; subject_length - 1 &amp;&amp;    /* we are at CRLF, */
-        subject[start_offset] == '\r' &amp;&amp;
-        subject[start_offset + 1] == '\n')
-      ovector[1] += 1;                          /* Advance by one more. */
-    else if (utf8)                              /* Otherwise, ensure we */
-      {                                         /* advance a whole UTF-8 */
-      while (ovector[1] &lt; subject_length)       /* character. */
-        {
-        if ((subject[ovector[1]] &amp; 0xc0) != 0x80) break;
-        ovector[1] += 1;
-        }
-      }
-    continue;    /* Go round the loop again */
-    }
-  /* Other matching errors are not recoverable. */
-  if (rc &lt; 0)
-    {
-    printf("Matching error %d\n", rc);
-    pcre_free(re);    /* Release memory used for the compiled pattern */
-    return 1;
-    }
-  /* Match succeded */
-  printf("\nMatch succeeded again at offset %d\n", ovector[0]);
-  /* The match succeeded, but the output vector wasn't big enough. */
-  if (rc == 0)
-    {
-    rc = OVECCOUNT/3;
-    printf("ovector only has room for %d captured substrings\n", rc - 1);
-    }
-  /* As before, show substrings stored in the output vector by number, and then
-  also any named substrings. */
-  for (i = 0; i &lt; rc; i++)
-    {
-    char *substring_start = subject + ovector[2*i];
-    int substring_length = ovector[2*i+1] - ovector[2*i];
-    printf("%2d: %.*s\n", i, substring_length, substring_start);
-    }
-  if (namecount &lt;= 0) printf("No named substrings\n"); else
-    {
-    unsigned char *tabptr = name_table;
-    printf("Named substrings\n");
-    for (i = 0; i &lt; namecount; i++)
-      {
-      int n = (tabptr[0] &lt;&lt; 8) | tabptr[1];
-      printf("(%d) %*s: %.*s\n", n, name_entry_size - 3, tabptr + 2,
-        ovector[2*n+1] - ovector[2*n], subject + ovector[2*n]);
-      tabptr += name_entry_size;
-      }
-    }
-  }      /* End of loop to find second and subsequent matches */
-printf("\n");
-pcre_free(re);       /* Release memory used for the compiled pattern */
-return 0;
-}
-/* End of pcredemo.c */
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>