PageRenderTime 40ms CodeModel.GetById 15ms RepoModel.GetById 0ms app.codeStats 1ms

/doc/index.html

http://github.com/edicl/cl-ppcre
HTML | 2206 lines | 1861 code | 345 blank | 0 comment | 0 complexity | b8d64a620f112e30367282f0960294fa MD5 | raw file
    

  1. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
    2. 

  2. <html> 
    3. 

  3. 

  4. <head>
    5. 

  5.   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
    6. 

  6.   <title>CL-PPCRE - Portable Perl-compatible regular expressions for Common Lisp</title>
    7. 

  7.   <style type="text/css">
    8. 

  8.   pre { padding:5px; background-color:#e0e0e0 }
    9. 

  9.   h3, h4 { text-decoration: underline; }
    10. 

  10.   a { text-decoration: none; padding: 1px 2px 1px 2px; }
    11. 

  11.   a:visited { text-decoration: none; padding: 1px 2px 1px 2px; }
    12. 

  12.   a:hover { text-decoration: none; padding: 1px 1px 1px 1px; border: 1px solid #000000; } 
    13. 

  13.   a:focus { text-decoration: none; padding: 1px 2px 1px 2px; border: none; }
    14. 

  14.   a.none { text-decoration: none; padding: 0; }
    15. 

  15.   a.none:visited { text-decoration: none; padding: 0; } 
    16. 

  16.   a.none:hover { text-decoration: none; border: none; padding: 0; } 
    17. 

  17.   a.none:focus { text-decoration: none; border: none; padding: 0; } 
    18. 

  18.   a.noborder { text-decoration: none; padding: 0; } 
    19. 

  19.   a.noborder:visited { text-decoration: none; padding: 0; } 
    20. 

  20.   a.noborder:hover { text-decoration: none; border: none; padding: 0; } 
    21. 

  21.   a.noborder:focus { text-decoration: none; border: none; padding: 0; }  
    22. 

  22.   pre.none { padding:5px; background-color:#ffffff }
    23. 

  23.   </style>
    24. 

  24.   <meta name="description" content="Fast and portable perl-compatible regular expressions for Common Lisp.">
    25. 

  25. </head>
    26. 

  26. 

  27. <body bgcolor=white>
    28. 

  28. 

  29. <h2>CL-PPCRE - Portable Perl-compatible regular expressions for Common Lisp</h2>
    30. 

  30. 

  31. <blockquote>
    32. 

  32. <br>&nbsp;<br><h3>Abstract</h3>
    33. 

  33. 

  34. CL-PPCRE is a portable regular expression library for Common Lisp
    35. 

  35. which has the following features:
    36. 

  36. 

  37. <ul>
    38. 

  38. 

  39. <li>It is <b>compatible with Perl</b>.
    40. 

  40. 

  41. <li>It is pretty <b>fast</b>.
    42. 

  42. 

  43. <li>It is <b>portable</b> between ANSI-compliant Common Lisp
    44. 

  44. implementations.
    45. 

  45. 

  46. <li>It is <b>thread-safe</b>.
    47. 

  47. 

  48. <li>In addition to specifying regular expressions as strings like in
    49. 

  49. Perl you can also use <a
    50. 

  50. href="#create-scanner2"><b>S-expressions</b></a>.
    51. 

  51. 

  52. <li>It comes with a <a
    53. 

  53. href="http://www.opensource.org/licenses/bsd-license.php"><b>BSD-style
    54. 

  54. license</b></a> so you can basically do with it whatever you want.
    55. 

  55. 

  56. </ul>
    57. 

  57. 

  58. CL-PPCRE has been used successfully in various applications like <a
    59. 

  59. href="http://nostoc.stanford.edu/Docs/">BioBike</a>, 
    60. 

  60. <a href="http://clutu.com/">clutu</a>,
    61. 

  61. <a
    62. 

  62. href="http://www.hpc.unm.edu/~download/LoGS/">LoGS</a>, <a href="http://cafespot.net/">CafeSpot</a>, <a href="http://www.eboy.com/">Eboy</a>, or <a
    63. 

  63. href="http://weitz.de/regex-coach/">The Regex Coach</a>.
    64. 

  64. 

  65. <p>
    66. 

  66. <font color=red>Download shortcut:</font> <a href="http://weitz.de/files/cl-ppcre.tar.gz">http://weitz.de/files/cl-ppcre.tar.gz</a>.
    67. 

  67. 

  68. </blockquote>
    69. 

  69. 

  70. <br>&nbsp;<br><h3><a class=none name="contents">Contents</a></h3>
    71. 

  71. <ol>
    72. 

  72.   <li><a href="#install">Download and installation</a>
    73. 

  73.   <li><a href="#support">Support</a>
    74. 

  74.   <li><a href="#dict">The CL-PPCRE dictionary</a>
    75. 

  75.   <ol>
    76. 

  76.     <li><a href="#scanning">Scanning</a>
    77. 

  77.     <ol>
    78. 

  78.       <li><a href="#create-scanner"><code>create-scanner</code></a> (for Perl regex strings)
    79. 

  79.       <li><a href="#create-scanner2"><code>create-scanner</code></a> (for parse trees)
    80. 

  80.       <li><a href="#scan"><code>scan</code></a>
    81. 

  81.       <li><a href="#scan-to-strings"><code>scan-to-strings</code></a>
    82. 

  82.       <li><a href="#register-groups-bind"><code>register-groups-bind</code></a>
    83. 

  83.       <li><a href="#do-scans"><code>do-scans</code></a>
    84. 

  84.       <li><a href="#do-matches"><code>do-matches</code></a>
    85. 

  85.       <li><a href="#do-matches-as-strings"><code>do-matches-as-strings</code></a>
    86. 

  86.       <li><a href="#do-register-groups"><code>do-register-groups</code></a>
    87. 

  87.       <li><a href="#all-matches"><code>all-matches</code></a>
    88. 

  88.       <li><a href="#all-matches-as-strings"><code>all-matches-as-strings</code></a>
    89. 

  89.     </ol>
    90. 

  90.     <li><a href="#splitting">Splitting and replacing</a>
    91. 

  91.     <ol>
    92. 

  92.       <li><a href="#split"><code>split</code></a>
    93. 

  93.       <li><a href="#regex-replace"><code>regex-replace</code></a>
    94. 

  94.       <li><a href="#regex-replace-all"><code>regex-replace-all</code></a>
    95. 

  95.     </ol>
    96. 

  96.     <li><a href="#modify">Modifying scanner behaviour</a>
    97. 

  97.     <ol>
    98. 

  98.       <li><a href="#*property-resolver*"><code>*property-resolver*</code></a>
    99. 

  99.       <li><a href="#parse-tree-synonym"><code>parse-tree-synonym</code></a>
    100. 

  100.       <li><a href="#define-parse-tree-synonym"><code>define-parse-tree-synonym</code></a>
    101. 

  101.       <li><a href="#*regex-char-code-limit*"><code>*regex-char-code-limit*</code></a>
    102. 

  102.       <li><a href="#*use-bmh-matchers*"><code>*use-bmh-matchers*</code></a>
    103. 

  103.       <li><a href="#*optimize-char-classes*"><code>*optimize-char-classes*</code></a>
    104. 

  104.       <li><a href="#*allow-quoting*"><code>*allow-quoting*</code></a>
    105. 

  105.       <li><a href="#*allow-named-registers*"><code>*allow-named-registers*</code></a>
    106. 

  106.     </ol>
    107. 

  107.     <li><a href="#misc">Miscellaneous</a>
    108. 

  108.     <ol>
    109. 

  109.       <li><a href="#parse-string"><code>parse-string</code></a>
    110. 

  110.       <li><a href="#create-optimized-test-function"><code>create-optimized-test-function</code></a>
    111. 

  111.       <li><a href="#quote-meta-chars"><code>quote-meta-chars</code></a>
    112. 

  112.       <li><a href="#regex-apropos"><code>regex-apropos</code></a>
    113. 

  113.       <li><a href="#regex-apropos-list"><code>regex-apropos-list</code></a>
    114. 

  114.     </ol>
    115. 

  115.     <li><a href="#conditions">Conditions</a>
    116. 

  116.     <ol>
    117. 

  117.       <li><a href="#ppcre-error"><code>ppcre-error</code></a>
    118. 

  118.       <li><a href="#ppcre-invocation-error"><code>ppcre-invocation-error</code></a>
    119. 

  119.       <li><a href="#ppcre-syntax-error"><code>ppcre-syntax-error</code></a>
    120. 

  120.       <li><a href="#ppcre-syntax-error-string"><code>ppcre-syntax-error-string</code></a>
    121. 

  121.       <li><a href="#ppcre-syntax-error-pos"><code>ppcre-syntax-error-pos</code></a>
    122. 

  122.     </ol>
    123. 

  123.   </ol>
    124. 

  124.   <li><a href="#unicode">Unicode properties</a>
    125. 

  125.   <ol>
    126. 

  126.       <li><a href="#unicode-property-resolver"><code>unicode-property-resolver</code></a>
    127. 

  127.   </ol>
    128. 

  128.   <li><a href="#filters">Filters</a>
    129. 

  129.   <li><a href="#perl">Compatibility with Perl</a>
    130. 

  130.     <ol>
    131. 

  131.       <li><a href="#empty">Empty strings instead of <code>undef</code> in <code>$1</code>, <code>$2</code>, etc.</a>
    132. 

  132.       <li><a href="#scope">Strange scoping of embedded modifiers</a>
    133. 

  133.       <li><a href="#inconsistent">Inconsistent capturing of <code>$1</code>, <code>$2</code>, etc.</a>
    134. 

  134.       <li><a href="#lookaround">Captured groups not available outside of look-aheads and look-behinds</a>
    135. 

  135.       <li><a href="#order">Alternations don't always work from left to right</a>
    136. 

  136.       <li><a href="#uprops">Different names for Unicode properties</a>
    137. 

  137.       <li><a href="#mac"><code>&quot;\r&quot;</code> doesn't work with MCL</a>
    138. 

  138.       <li><a href="#alpha">What about <code>&quot;\w&quot;</code>?</a>
    139. 

  139.     </ol>
    140. 

  140.   <li><a href="#bugs">Bugs and problems</a>
    141. 

  141.   <ol>
    142. 

  142.     <li><a href="#quote"><code>&quot;\Q&quot;</code> doesn't work, or does it?</a>
    143. 

  143.     <li><a href="#backslash">Backslashes may confuse you...</a>
    144. 

  144.   </ol>
    145. 

  145.   <li><a href="#allegro">AllegroCL compatibility mode</a>
    146. 

  146.   <li><a href="#blabla">Hints, comments, performance considerations</a>
    147. 

  147.   <li><a href="#ack">Acknowledgements</a>
    148. 

  148. </ol>
    149. 

  149. 

  150. <br>&nbsp;<br><h3><a name="install" class=none>Download and installation</a></h3>
    151. 

  151. 

  152. CL-PPCRE together with this documentation can be downloaded from <a
    153. 

  153. href="http://weitz.de/files/cl-ppcre.tar.gz">http://weitz.de/files/cl-ppcre.tar.gz</a>. The
    154. 

  154. current version is 2.0.11.
    155. 

  155. <p>
    156. 

  156. CL-PPCRE comes with a system definition
    157. 

  157. for <a href="http://www.cliki.net/asdf">ASDF</a> and you compile and
    158. 

  158. load it in the usual way.  There are no dependencies (except that the
    159. 

  159. <a href="#test">test suite</a> which is not needed for normal operation depends
    160. 

  160. on <a href="http://weitz.de/flexi-streams/">FLEXI-STREAMS</a>).
    161. 

  161. <p>
    162. 

  162.   The preferred way to install CL-PPCRE is
    163. 

  163. through <a href="http://www.quicklisp.org/" target="_new">Quicklisp</a>:
    164. 

  164.   <pre>(ql:quickload :cl-ppcre)</pre>
    165. 

  165. </p>
    166. 

  166. <p>
    167. 

  167. <a class=none name="test">You</a> can run a test suite which tests most aspects of the library with
    168. 

  168. <pre>
    169. 

  169. (asdf:oos 'asdf:test-op :cl-ppcre)
    170. 

  170. </pre>
    171. 

  171. <p>
    172. 

  172. The current development version of CL-PPCRE can be found
    173. 

  173. at <a href="https://github.com/edicl/cl-ppcre">https://github.com/edicl/cl-ppcre</a>. If you want to send patches, please fork the github repository and send pull requests. 
    174. 

  174. <p>
    175. 

  175. 

  176. <br>&nbsp;<br><h3><a name="support" class=none>Support</a></h3>
    177. 

  177. 

  178. The development version of cl-ppcre can be
    179. 

  179. found <a href="https://github.com/edicl/cl-ppcre" target="_new">on
    180. 

  180. github</a>.  Please use the github issue tracking system to submit bug
    181. 

  181. reports.  Patches are welcome, please
    182. 

  182. use <a href="https://github.com/edicl/cl-ppcre/pulls">GitHub pull
    183. 

  183. requests</a>.  If you want to make a change,
    184. 

  184. please <a href="http://weitz.de/patches.html" target="_new">read this
    185. 

  185. first</a>.
    186. 

  186. 

  187. <br>&nbsp;<br><h3><a class=none name="dict">The CL-PPCRE dictionary</a></h3>
    188. 

  188. 

  189. <h4><a name="scanning" class=none>Scanning</a></h4>
    190. 

  190. 

  191. <p><br>[Method]
    192. 

  192. <br><a class=none name="create-scanner"><b>create-scanner</b> <i>(string string)<tt>&amp;key</tt> case-insensitive-mode multi-line-mode single-line-mode extended-mode destructive</i> =&gt; <i>scanner, register-names</i></a>
    193. 

  193. 

  194. <blockquote><br> Accepts a string which is a regular expression in
    195. 

  195. Perl syntax and returns a closure which will scan strings for this
    196. 

  196. regular expression. The second value is only returned if <a href="#*allow-named-registers*"><code>*ALLOW-NAMED-REGISTERS*</code></a> is <i>true</i>. It represents a list of strings mapping registers to their respective names - the first element stands for first register, the second element for second register, etc. You have to store this value if you want to map a register number to its name later as <i>scanner</i> doesn't capture any information about register names. If a register isn't named, it has NIL as its name.
    197. 

  197. <p>
    198. 

  198. The mode keyword arguments are equivalent to the
    199. 

  199. <code>&quot;imsx&quot;</code> modifiers in Perl. The
    200. 

  200. <code>destructive</code> keyword will be ignored.
    201. 

  201. <p>
    202. 

  202. The function accepts most of the regex syntax of Perl 5.8 as described
    203. 

  203. in <a href="http://perldoc.perl.org/5.8.8/perlre.html"><code>man
    204. 

  204. perlre</code></a> including extended features like non-greedy
    205. 

  205. repetitions, positive and negative look-ahead and look-behind
    206. 

  206. assertions, &quot;standalone&quot; subexpressions, and conditional
    207. 

  207. subpatterns. The following Perl features are (currently) <b>not</b>
    208. 

  208. supported:
    209. 

  209. 

  210. <ul>
    211. 

  211. 

  212. <li><code>(?{ code })</code> and <code>(??{ code })</code> because
    213. 

  213. they obviously don't make sense in Lisp.
    214. 

    215. 

  215. <li><code>\N{name}</code> (named characters), <code>\x{263a}</code>
    216. 

  216. (wide hex characters), <code>\l</code>, <code>\u</code>,
    217. 

  217. <code>\L</code>, and <code>\U</code>
    218. 

  218. because they're actually not part of Perl's <em>regex</em> syntax - but see <a href="http://weitz.de/cl-interpol/">CL-INTERPOL</a>.
    219. 

  219. 

  220. <li><code>\X</code> (extended Unicode), and <code>\C</code> (single
    221. 

  221. character). But you can of course use all characters
    222. 

  222. supported by your CL implementation.
    223. 

  223. 

  224. <li>Posix character classes like <code>[[:alpha]]</code>.
    225. 

  225. Use <a href="#unicode">Unicode properties</a> instead.
    226. 

  226. 

  227. <li><code>\G</code> for Perl's <code>pos()</code> because we don't have it.
    228. 

  228. 

  229. </ul>
    230. 

  230. 

  231. Note, however, that <code>\t</code>, <code>\n</code>, <code>\r</code>,
    232. 

  232. <code>\f</code>, <code>\a</code>, <code>\e</code>, <code>\033</code>
    233. 

  233. (octal character codes), <code>\x1B</code> (hexadecimal character
    234. 

  234. codes), <code>\c[</code> (control characters), <code>\w</code>,
    235. 

  235. <code>\W</code>, <code>\s</code>, <code>\S</code>, <code>\d</code>,
    236. 

  236. <code>\D</code>, <code>\b</code>, <code>\B</code>, <code>\A</code>,
    237. 

  237. <code>\Z</code>, and <code>\z</code> <b>are</b> supported.
    238. 

  238. <p>
    239. 

  239. Since version 0.6.0, CL-PPCRE also supports Perl's <code>\Q</code> and <code>\E</code> - see <a
    240. 

  240. href="#*allow-quoting*"><code>*ALLOW-QUOTING*</code></a> below. Make sure you also read <a href="#quote">the relevant section</a> in &quot;<a href="#bugs">Bugs and problems</a>.&quot;
    241. 

  241. <p>
    242. 

  242. Since version 1.3.0, CL-PPCRE offers support for <a href="http://www.franz.com/support/documentation/7.0/doc/regexp.htm#regexp-new-capturing-2">AllegroCL's</a> <code>(?&lt;name&gt;"&lt;regex&gt;")</code>  named registers and <code>\k&lt;name&gt;</code> back-references syntax, have a look at <a href="#*allow-named-registers*"><code>*ALLOW-NAMED-REGISTERS*</code></a> for details.
    243. 

  243. <p>
    244. 

  244. Since version 2.0.0, CL-PPCRE
    245. 

  245. supports <a href="#*property-resolver*">named properties</a>
    246. 

  246. (<code>\p</code> and <code>\P</code>), but only the long form with
    247. 

  247. braces is supported, i.e. <code>\p{Letter}</code>
    248. 

  248. and <code>\p{L}</code> will work while <code>\pL</code> won't.
    249. 

  249. <p>
    250. 

  250. The keyword arguments are just for your
    251. 

  251. convenience. You can always use embedded modifiers like
    252. 

  252. <code>&quot;(?i-s)&quot;</code> instead.</blockquote>
    253. 

  253. 

  254. <p><br>[Method]
    255. 

  255. <br><a class=none name="create-scanner"><b>create-scanner</b> <i>(function function)<tt>&amp;key</tt> case-insensitive-mode multi-line-mode single-line-mode extended-mode destructive</i> =&gt; <i>scanner</i></a>
    256. 

  256. <blockquote><br> In this case <code><i>function</i></code> should be a
    257. 

  257. scanner returned by another invocation
    258. 

  258. of <code>CREATE-SCANNER</code>. It will be returned as is.  You can't
    259. 

  259. use any of the keyword arguments because the scanner has already been
    260. 

  260. created and is immutable.
    261. 

  261. </blockquote>
    262. 

  262. 

  263. <p><br>[Method]
    264. 

  264. <br><a class=none name="create-scanner2"><b>create-scanner</b> <i>(parse-tree t)<tt>&amp;key</tt> case-insensitive-mode multi-line-mode single-line-mode extended-mode destructive</i> =&gt; <i>scanner, register-names</i></a>
    265. 

  265. <blockquote><br>
    266. 

  266. This is similar to <a
    267. 

  267. href="#create-scanner"><code>CREATE-SCANNER</code></a> for regex strings above but
    268. 

  268. accepts a <em>parse tree</em> as its first argument. A parse tree is an S-expression
    269. 

  269. conforming to the following syntax:
    270. 

  270. 

  271. <ul>
    272. 

  272. 

  273. <li>Every string and character is a parse tree and is treated
    274. 

  274. <em>literally</em> as a part of the regular expression,
    275. 

  275. i.e. parentheses, brackets, asterisks and such aren't special.
    276. 

    277. 

  277. <li>The symbol <code>:VOID</code> is equivalent to the empty string.
    278. 

  278. 

  279. <li>The symbol <code>:EVERYTHING</code> is equivalent to Perl's dot,
    280. 

  280. i.e it matches everything (except maybe a newline character depending
    281. 

  281. on the mode).
    282. 

  282. 

  283. <li>The symbols <code>:WORD-BOUNDARY</code> and
    284. 

  284. <code>:NON-WORD-BOUNDARY</code> are equivalent to Perl's
    285. 

  285. <code>&quot;\b&quot;</code> and <code>&quot;\B&quot;</code>.
    286. 

  286. 

  287. <li>The symbols <code>:DIGIT-CLASS</code>,
    288. 

  288. <code>:NON-DIGIT-CLASS</code>, <code>:WORD-CHAR-CLASS</code>,
    289. 

  289. <code>:NON-WORD-CHAR-CLASS</code>,
    290. 

  290. <code>:WHITESPACE-CHAR-CLASS</code>, and
    291. 

  291. <code>:NON-WHITESPACE-CHAR-CLASS</code> are equivalent to Perl's
    292. 

  292. <em>special character classes</em> <code>&quot;\d&quot;</code>,
    293. 

  293. <code>&quot;\D&quot;</code>, <code>&quot;\w&quot;</code>,
    294. 

  294. <code>&quot;\W&quot;</code>, <code>&quot;\s&quot;</code>, and
    295. 

  295. <code>&quot;\S&quot;</code> respectively.
    296. 

  296. 

  297. <li>The symbols <code>:START-ANCHOR</code>, <code>:END-ANCHOR</code>,
    298. 

  298. <code>:MODELESS-START-ANCHOR</code>,
    299. 

  299. <code>:MODELESS-END-ANCHOR</code>, and
    300. 

  300. <code>:MODELESS-END-ANCHOR-NO-NEWLINE</code> are equivalent to Perl's
    301. 

  301. <code>&quot;^&quot;</code>, <code>&quot;$&quot;</code>,
    302. 

  302. <code>&quot;\A&quot;</code>, <code>&quot;\Z&quot;</code>, and
    303. 

  303. <code>&quot;\z&quot;</code> respectively.
    304. 

  304. 

  305. <li>The symbols <code>:CASE-INSENSITIVE-P</code>,
    306. 

  306. <code>:CASE-SENSITIVE-P</code>, <code>:MULTI-LINE-MODE-P</code>,
    307. 

  307. <code>:NOT-MULTI-LINE-MODE-P</code>, <code>:SINGLE-LINE-MODE-P</code>,
    308. 

  308. and <code>:NOT-SINGLE-LINE-MODE-P</code> are equivalent to Perl's
    309. 

  309. <em>embedded modifiers</em> <code>&quot;(?i)&quot;</code>,
    310. 

  310. <code>&quot;(?-i)&quot;</code>, <code>&quot;(?m)&quot;</code>,
    311. 

  311. <code>&quot;(?-m)&quot;</code>, <code>&quot;(?s)&quot;</code>, and
    312. 

  312. <code>&quot;(?-s)&quot;</code>. As usual, changes applied to modes are
    313. 

  313. kept local to the innermost enclosing grouping or clustering
    314. 

  314. construct.
    315. 

  315. 

  316. </li><li>All other symbols will signal an error of type <a
    317. 

  317. href="#ppcre-syntax-error"><code>PPCRE-SYNTAX-ERROR</code></a>
    318. 

  318. <em>unless</em> they are defined to be <a
    319. 

  319. href="#parse-tree-synonym"><em>parse tree synonyms</em></a>.
    320. 

  320. 

  321. <li><code>(:FLAGS {&lt;modifier&gt;}*)</code> where
    322. 

  322. <code>&lt;modifier&gt;</code> is one of the modifier symbols from
    323. 

  323. above is used to group modifier symbols. The modifiers are applied
    324. 

  324. from left to right. (This construct is obviously redundant. It is only
    325. 

  325. there because it's used by the parser.)
    326. 

    327. 

  327. <li><code>(:SEQUENCE {&lt;<i>parse-tree</i>&gt;}*)</code> means a
    328. 

  328. sequence of parse trees, i.e. the parse trees must match one after
    329. 

  329. another. Example: <code>(:SEQUENCE #\f #\o #\o)</code> is equivalent
    330. 

  330. to the parse tree <code>&quot;foo&quot;</code>.
    331. 

  331. 

  332. <li><code>(:GROUP {&lt;<i>parse-tree</i>&gt;}*)</code> is like
    333. 

  333. <code>:SEQUENCE</code> but changes applied to modifier flags (see
    334. 

  334. above) are kept local to the parse trees enclosed by this
    335. 

  335. construct. Think of it as the S-expression variant of Perl's
    336. 

  336. <code>&quot;(?:&lt;<i>pattern</i>&gt;)&quot;</code> construct.
    337. 

  337. 

  338. <li><code>(:ALTERNATION {&lt;<i>parse-tree</i>&gt;}*)</code> means an
    339. 

  339. alternation of parse trees, i.e. one of the parse trees must
    340. 

  340. match. Example: <code>(:ALTERNATION #\b #\a #\z)</code> is equivalent
    341. 

  341. to the Perl regex string <code>&quot;b|a|z&quot;</code>.
    342. 

  342. 

  343. <li><code>(:BRANCH &lt;<i>test</i>&gt;
    344. 

  344. &lt;<i>parse-tree</i>&gt;)</code> is for conditional regular
    345. 

  345. expressions. <code>&lt;<i>test</i>&gt;</code> is either a number which
    346. 

  346. stands for a register or a parse tree which is a look-ahead or
    347. 

  347. look-behind assertion. See the entry for
    348. 

  348. <code>(?(&lt;<i>condition</i>&gt;)&lt;<i>yes-pattern</i>&gt;|&lt;<i>no-pattern</i>&gt;)</code>
    349. 

  349. in <a
    350. 

  350. href="http://perldoc.perl.org/perlre.html#Extended-Patterns"><code>man
    351. 

  351. perlre</code></a> for the semantics of this construct. If
    352. 

  352. <code>&lt;<i>parse-tree</i>&gt;</code> is an alternation is
    353. 

  353. <em>must</em> enclose exactly one or two parse trees where the second
    354. 

  354. one (if present) will be treated as the &quot;no-pattern&quot; - in
    355. 

  355. all other cases <code>&lt;<i>parse-tree</i>&gt;</code> will be treated
    356. 

  356. as the &quot;yes-pattern&quot;.
    357. 

  357. 

  358. <li><code>(:POSITIVE-LOOKAHEAD|:NEGATIVE-LOOKAHEAD|:POSITIVE-LOOKBEHIND|:NEGATIVE-LOOKBEHIND
    359. 

  359. &lt;<i>parse-tree</i>&gt;)</code> should be pretty obvious...
    360. 

  360. 

  361. <li><code>(:GREEDY-REPETITION|:NON-GREEDY-REPETITION
    362. 

  362. &lt;<i>min</i>&gt; &lt;<i>max</i>&gt;
    363. 

  363. &lt;<i>parse-tree</i>&gt;)</code> where
    364. 

  364. <code>&lt;<i>min</i>&gt;</code> is a non-negative integer and
    365. 

  365. <code>&lt;<i>max</i>&gt;</code> is either a non-negative integer not
    366. 

  366. smaller than <code>&lt;<i>min</i>&gt;</code> or <code>NIL</code> will
    367. 

  367. result in a regular expression which tries to match
    368. 

  368. <code>&lt;<i>parse-tree</i>&gt;</code> at least
    369. 

  369. <code>&lt;<i>min</i>&gt;</code> times and at most
    370. 

  370. <code>&lt;<i>max</i>&gt;</code> times (or as often as possible if
    371. 

  371. <code>&lt;<i>max</i>&gt;</code> is <code>NIL</code>). So, e.g.,
    372. 

  372. <code>(:NON-GREEDY-REPETITION 0 1 &quot;ab&quot;)</code> is equivalent
    373. 

  373. to the Perl regex string <code>&quot;(?:ab)??&quot;</code>.
    374. 

  374. 

  375. <li><code>(:STANDALONE &lt;<i>parse-tree</i>&gt;)</code> is an
    376. 

  376. &quot;independent&quot; subexpression, i.e. <code>(:STANDALONE
    377. 

  377. &quot;bar&quot;)</code> is equivalent to the Perl regex string
    378. 

  378. <code>&quot;(?>bar)&quot;</code>.
    379. 

  379. 

  380. <li><code>(:REGISTER &lt;<i>parse-tree</i>&gt;)</code> is a capturing
    381. 

  381. register group. As usual, registers are counted from left to right
    382. 

  382. beginning with 1.
    383. 

  383. 

  384. <li><code>(:NAMED-REGISTER &lt;<i>name</i>&gt; &lt;<i>parse-tree</i>&gt;)</code> is a named capturing
    385. 

  385. register group. Acts as <code>:REGISTER</code>, but assigns <code>&lt;<i>name</i>&gt;</code> to a register too. This <code>&lt;<i>name</i>&gt;</code> can be later referred to via <code>:BACK-REFERENCE</code>. Names are case-sensitive and don't need to be unique. See <a href="#*allow-named-registers*"><code>*ALLOW-NAMED-REGISTERS*</code></a> for details.
    386. 

    387. 

  387. 

  388. <li><code>(:BACK-REFERENCE &lt;<i>ref</i>&gt;)</code> is a
    389. 

  389. back-reference to a register group. <code>&lt;<i>ref</i>&gt;</code> is
    390. 

  390. a positive integer or a string denoting a register name. If there are
    391. 

  391. several registers with the same name, the regex engine tries to
    392. 

  392. successfully match at least of them, starting with the most recently
    393. 

  393. seen register continuing to the least recently seen one, until a match
    394. 

  394. is found. See <a
    395. 

  395. href="#*allow-named-registers*"><code>*ALLOW-NAMED-REGISTERS*</code></a>
    396. 

  396. for more information.
    397. 

  397. 

  398. <li><code>(:PROPERTY|:INVERTED-PROPERTY &lt;<i>property</i>&gt;)</code> is
    399. 

  399. a <a href="#*property-resolver*">named property</a> (or its inverse) with
    400. 

  400. <code>&lt;<i>property</i>&gt;</code> being a function designator or a
    401. 

  401. string which must be resolved
    402. 

  402. by <a href="#*property-resolver*"><code>*PROPERTY-RESOLVER*</code></a>.
    403. 

  403. 

  404. <li><a class=none name="filterdef"><code>(:FILTER &lt;<i>function</i>&gt; <tt>&amp;optional</tt>
    405. 

  405. &lt;<i>length</i>&gt;)</code></a> where
    406. 

  406. <code>&lt;<i>function</i>&gt;</code> is a <a
    407. 

  407. href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_f.htm#function_designator">function
    408. 

  408. designator</a> and <code>&lt;<i>length</i>&gt;</code> is a
    409. 

  409. non-negative integer or <code>NIL</code> is a user-defined <a
    410. 

  410. href="#filters">filter</a>.
    411. 

  411. 

  412. <li><code>(:REGEX &lt;<i>string</i>&gt;)</code> where
    413. 

  413. <code>&lt;<i>string</i>&gt;</code> is an
    414. 

  414. embedded <a href="#create-scanner">regular expression in Perl
    415. 

  415. syntax</a>.
    416. 

  416. 

  417. <li><code>(:CHAR-CLASS|:INVERTED-CHAR-CLASS
    418. 

  418. {&lt;<i>item</i>&gt;}*)</code> where <code>&lt;<i>item</i>&gt;</code>
    419. 

  419. is either a character, a <em>character range</em>, a named property
    420. 

  420. (see above), or a symbol for a special character class (see above)
    421. 

  421. will be translated into a (one character wide) character
    422. 

  422. class. A <em>character range</em> looks like
    423. 

  423. <code>(:RANGE &lt;<i>char1</i>&gt; &lt;<i>char2</i>&gt;)</code> where
    424. 

  424. <code>&lt;<i>char1</i>&gt;</code> and
    425. 

  425. <code>&lt;<i>char2</i>&gt;</code> are characters such that
    426. 

  426. <code>(CHAR&lt;= &lt;<i>char1</i>&gt; &lt;<i>char2</i>&gt;)</code> is
    427. 

  427. true. Example: <code>(:INVERTED-CHAR-CLASS #\a (:RANGE #\D #\G)
    428. 

  428. :DIGIT-CLASS)</code> is equivalent to the Perl regex string
    429. 

  429. <code>&quot;[^aD-G\d]&quot;</code>.
    430. 

  430. 

  431. </ul>
    432. 

  432. 

  433. Because <code>CREATE-SCANNER</code> is defined as a generic function
    434. 

  434. which dispatches on its first argument there's a certain ambiguity:
    435. 

  435. Although strings are valid parse trees they will be interpreted as
    436. 

  436. Perl regex strings when given to <code>CREATE-SCANNER</code>. To
    437. 

  437. circumvent this you can always use the equivalent parse tree <code>(:GROUP
    438. 

  438. &lt;<i>string</i>&gt;)</code> instead.
    439. 

  439. <p>
    440. 

  440. Note that <code>CREATE-SCANNER</code> doesn't always check
    441. 

  441. for the well-formedness of its first argument, i.e. you are expected
    442. 

  442. to provide <em>correct</em> parse trees.
    443. 

  443. 

  444. <p>
    445. 

  445. The usage of the keyword argument <code>extended-mode</code> obviously
    446. 

  446. doesn't make sense if <code>CREATE-SCANNER</code> is applied to parse
    447. 

  447. trees and will signal an error.
    448. 

  448. <p>
    449. 

  449. If <code>destructive</code> is not <code>NIL</code> (the default is
    450. 

  450. <code>NIL</code>), the function is allowed to destructively modify
    451. 

  451. <code><i>parse-tree</i></code> while creating the scanner.
    452. 

  452. <p>
    453. 

  453. If you want to find out how parse trees are related to Perl regex
    454. 

  454. strings, you should play around with
    455. 

  455. <a href="#parse-string"><code>PARSE-STRING</code></a>:
    456. 

  456. 

  457. <pre>
    458. 

  458. * (parse-string "(ab)*")
    459. 

  459. (:GREEDY-REPETITION 0 NIL (:REGISTER "ab"))
    460. 

  460. 

  461. * (parse-string "(a(b))")
    462. 

  462. (:REGISTER (:SEQUENCE #\a (:REGISTER #\b)))
    463. 

  463. 

  464. * (parse-string "(?:abc){3,5}")
    465. 

  465. (:GREEDY-REPETITION 3 5 (:GROUP "abc"))
    466. 

  466. <font color=orange>;; (:GREEDY-REPETITION 3 5 "abc") would also be OK</font>
    467. 

  467. 

  468. * (parse-string "a(?i)b(?-i)c")
    469. 

  469. (:SEQUENCE #\a
    470. 

  470.  (:SEQUENCE (:FLAGS :CASE-INSENSITIVE-P)
    471. 

  471.   (:SEQUENCE #\b (:SEQUENCE (:FLAGS :CASE-SENSITIVE-P) #\c))))
    472. 

  472. <font color=orange>;; same as (:SEQUENCE #\a :CASE-INSENSITIVE-P #\b :CASE-SENSITIVE-P #\c)</font>
    473. 

  473. 

  474. * (parse-string "(?=a)b")
    475. 

  475. (:SEQUENCE (:POSITIVE-LOOKAHEAD #\a) #\b)
    476. 

  476. </pre></blockquote>
    477. 

  477. 

  478. <p><br>
    479. 

  479. <font color=green><b>For the rest of the dictionary, </b><code><i>regex</i></code><b> can
    480. 

  480. always be a string (which is interpreted as a Perl regular
    481. 

  481. expression), a parse tree, or a scanner created by
    482. 

  482. <a href="#create-scanner"><font color=green><code>CREATE-SCANNER</code></font></a>.  The
    483. 

  483. </b><code><i>start</i></code><b> and </b><code><i>end</i></code><b>
    484. 

  484. keyword parameters are always used as in <a
    485. 

  485. href="#scan"><font color=green><code>SCAN</code></font></a>.</b></font>
    486. 

  486. 

  487. 

  488. 

  489. 

  490. <p><br>[Generic Function]
    491. 

  491. <br><a class=none name="scan"><b>scan</b> <i>regex target-string <tt>&amp;key</tt> start end</i> =&gt; <i>match-start, match-end, reg-starts, reg-ends</i></a>
    492. 

  492. 

  493. <blockquote><br>
    494. 

  494. Searches the string <code><i>target-string</i></code>
    495. 

  495. from <code><i>start</i></code> (which defaults to 0) to
    496. 

  496. <code><i>end</i></code> (which default to the length of
    497. 

  497. <code><i>target-string</i></code>) and tries to match
    498. 

  498. <code><i>regex</i></code>. On success returns four values - the start
    499. 

  499. of the match, the end of the match, and two arrays denoting the
    500. 

  500. beginnings and ends of register matches. On failure returns
    501. 

  501. <code>NIL</code>.  <code><i>target-string</i></code> will be coerced
    502. 

  502. to a simple string if it isn't one already. (There's another keyword
    503. 

  503. parameter <code><i>real-start-pos</i></code>.  This one should
    504. 

  504. <em>never</em> be set from user code - it is only used internally.)
    505. 

  505. <p>
    506. 

  506. <code>SCAN</code> acts as if the part of
    507. 

  507. <code><i>target-string</i></code> between <code><i>start</i></code>
    508. 

  508. and <code><i>end</i></code> were a standalone string, i.e. look-aheads
    509. 

  509. and look-behinds can't look beyond these boundaries.
    510. 

  510. <pre>
    511. 

  511. * (scan "(a)*b" "xaaabd")
    512. 

  512. 1
    513. 

  513. 5
    514. 

  514. #(3)
    515. 

  515. #(4)
    516. 

  516. 

  517. * (scan "(a)*b" "xaaabd" :start 1)
    518. 

  518. 1
    519. 

  519. 5
    520. 

  520. #(3)
    521. 

  521. #(4)
    522. 

  522. 

  523. * (scan "(a)*b" "xaaabd" :start 2)
    524. 

  524. 2
    525. 

  525. 5
    526. 

  526. #(3)
    527. 

  527. #(4)
    528. 

  528. 

  529. * (scan "(a)*b" "xaaabd" :end 4)
    530. 

  530. NIL
    531. 

  531. 

  532. * (scan '(:greedy-repetition 0 nil #\b) "bbbc")
    533. 

  533. 0
    534. 

  534. 3
    535. 

  535. #()
    536. 

  536. #()
    537. 

  537. 

  538. * (scan '(:greedy-repetition 4 6 #\b) "bbbc")
    539. 

  539. NIL
    540. 

  540. 

  541. * (let ((s (create-scanner "(([a-c])+)x")))
    542. 

  542.     (scan s "abcxy"))
    543. 

  543. 0
    544. 

  544. 4
    545. 

  545. #(0 2)
    546. 

  546. #(3 3)
    547. 

  547. </pre></blockquote>
    548. 

  548. 

  549. 

  550. 

  551. <p><br>[Function]
    552. 

  552. <br><a class=none name="scan-to-strings"><b>scan-to-strings</b> <i>regex target-string <tt>&amp;key</tt> start end sharedp</i> =&gt; <i>match, regs</i></a>
    553. 

  553. 

  554. <blockquote><br>
    555. 

  555. Like <a href="#scan"><code>SCAN</code></a> but returns substrings of
    556. 

  556. <code><i>target-string</i></code> instead of positions, i.e. this
    557. 

  557. function returns two values on success: the whole match as a string
    558. 

  558. plus an array of substrings (or <code>NIL</code>s) corresponding to
    559. 

  559. the matched registers. If <code><i>sharedp</i></code> is true, the substrings may share structure with
    560. 

  560. <code><i>target-string</i></code>.
    561. 

  561. <pre>
    562. 

  562. * (scan-to-strings "[^b]*b" "aaabd")
    563. 

  563. "aaab"
    564. 

  564. #()
    565. 

  565. 

  566. * (scan-to-strings "([^b])*b" "aaabd")
    567. 

  567. "aaab"
    568. 

  568. #("a")
    569. 

  569. 

  570. * (scan-to-strings "(([^b])*)b" "aaabd")
    571. 

  571. "aaab"
    572. 

  572. #("aaa" "a")
    573. 

  573. </pre></blockquote>
    574. 

  574. 

  575. 

  576. <p><br>[Macro]
    577. 

  577. <br><a class=none name="register-groups-bind"><b>register-groups-bind</b> <i>var-list (regex target-string <tt>&amp;key</tt> start end sharedp) declaration* statement*</i> =&gt; <i>result*</i></a>
    578. 

  578. 

  579. <blockquote><br>
    580. 

  580. Evaluates <code><i>statement*</i></code> with the variables in <code><i>var-list</i></code> bound to the
    581. 

  581. corresponding register groups after <code><i>target-string</i></code> has been matched
    582. 

  582. against <code><i>regex</i></code>, i.e. each variable is either
    583. 

  583. bound to a string or to <code>NIL</code>.
    584. 

  584. As a shortcut, the elements of <code><i>var-list</i></code> can also be lists of the form <code>(FN&nbsp;VAR)</code> where <code>VAR</code> is the variable symbol
    585. 

  585. and <code>FN</code> is a <a
    586. 

  586. href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_f.htm#function_designator">function
    587. 

  587. designator</a> (which is evaluated) denoting a function which is to be applied to the string before the result is bound to <code>VAR</code>.
    588. 

  588. To make this even more convenient the form <code>(FN&nbsp;VAR1&nbsp;...VARn)</code> can be used as an abbreviation for
    589. 

  589. <code>(FN&nbsp;VAR1)&nbsp;...&nbsp;(FN&nbsp;VARn)</code>.
    590. 

  590. <p>
    591. 

  591. If there is no match, the <code><i>statement*</i></code> forms are <em>not</em>
    592. 

  592. executed. For each element of
    593. 

  593. <code><i>var-list</i></code> which is <code>NIL</code> there's no binding to the corresponding register
    594. 

  594. group. The number of variables in <code><i>var-list</i></code> must not be greater than
    595. 

  595. the number of register groups. If <code><i>sharedp</i></code> is true, the substrings may
    596. 

  596. share structure with <code><i>target-string</i></code>.
    597. 

  597. <pre>
    598. 

  598. * (register-groups-bind (first second third fourth)
    599. 

  599.       (&quot;((a)|(b)|(c))+&quot; &quot;abababc&quot; :sharedp t)
    600. 

  600.     (list first second third fourth))
    601. 

  601. (&quot;c&quot; &quot;a&quot; &quot;b&quot; &quot;c&quot;)
    602. 

  602. 

  603. * (register-groups-bind (nil second third fourth)
    604. 

  604.       <font color=orange>;; note that we don't bind the first and fifth register group</font>
    605. 

  605.       (&quot;((a)|(b)|(c))()+&quot; &quot;abababc&quot; :start 6)
    606. 

  606.     (list second third fourth))
    607. 

  607. (NIL NIL &quot;c&quot;)
    608. 

  608. 

  609. * (register-groups-bind (first)
    610. 

  610.       (&quot;(a|b)+&quot; &quot;accc&quot; :start 1)
    611. 

  611.     (format t &quot;This will not be printed: ~A&quot; first))
    612. 

  612. NIL
    613. 

  613. 

  614. * (register-groups-bind (fname lname (#'parse-integer date month year))
    615. 

  615.       (&quot;(\\w+)\\s+(\\w+)\\s+(\\d{1,2})\\.(\\d{1,2})\\.(\\d{4})&quot; &quot;Frank Zappa 21.12.1940&quot;)
    616. 

  616.     (list fname lname (encode-universal-time 0 0 0 date month year 0)))
    617. 

  617. ("Frank" "Zappa" 1292889600)
    618. 

  618. </pre>
    619. 

  619. </blockquote>
    620. 

  620. 

  621. <p><br>[Macro]
    622. 

  622. <br><a class=none name="do-scans"><b>do-scans</b> <i>(match-start match-end reg-starts reg-ends regex target-string <tt>&amp;optional</tt> result-form <tt>&amp;key</tt> start end) declaration* statement*</i> =&gt; <i>result*</i></a>
    623. 

  623. 

  624. <blockquote><br>
    625. 

  625. A macro which iterates over <code><i>target-string</i></code> and
    626. 

  626. tries to match <code><i>regex</i></code> as often as possible
    627. 

  627. evaluating <code><i>statement*</i></code> with
    628. 

  628. <code><i>match-start</i></code>, <code><i>match-end</i></code>,
    629. 

  629. <code><i>reg-starts</i></code>, and <code><i>reg-ends</i></code> bound
    630. 

  630. to the four return values of each match (see <a
    631. 

  631. href="#scan"><code>SCAN</code></a>) in turn. After the last match,
    632. 

  632. returns <code><i>result-form</i></code> if provided or
    633. 

  633. <code>NIL</code> otherwise. An implicit block named <code>NIL</code>
    634. 

  634. surrounds <code>DO-SCANS</code>; <code>RETURN</code> may be used to
    635. 

  635. terminate the loop immediately. If <code><i>regex</i></code> matches
    636. 

  636. an empty string, the scan is continued one position behind this match.
    637. 

  637. <p>
    638. 

  638. This is the most general macro to iterate over all matches in a target
    639. 

  639. string. See the source code of <a
    640. 

  640. href="#do-matches"><code>DO-MATCHES</code></a>, <a
    641. 

  641. href="#all-matches"><code>ALL-MATCHES</code></a>, <a
    642. 

  642. href="#split"><code>SPLIT</code></a>, or <a
    643. 

  643. href="#regex-replace-all"><code>REGEX-REPLACE-ALL</code></a> for examples of its
    644. 

  644. usage.</blockquote>
    645. 

  645. 

  646. 

  647. 

  648. 

  649. <p><br>[Macro]
    650. 

  650. <br><a class=none name="do-matches"><b>do-matches</b> <i>(match-start match-end regex target-string <tt>&amp;optional</tt> result-form <tt>&amp;key</tt> start end) declaration* statement*</i> =&gt; <i>result*</i></a>
    651. 

  651. 

  652. <blockquote><br>
    653. 

  653. Like <a href="#do-scans"><code>DO-SCANS</code></a> but doesn't bind
    654. 

  654. variables to the register arrays.
    655. 

  655. <pre>
    656. 

  656. * (defun foo (regex target-string &amp;key (start 0) (end (length target-string)))
    657. 

  657.     (let ((sum 0))
    658. 

  658.       (do-matches (s e regex target-string nil :start start :end end)
    659. 

  659.         (incf sum (- e s)))
    660. 

  660.       (format t "~,2F% of the string was inside of a match~%"
    661. 

  661.                 <font color=orange>;; note: doesn't check for division by zero</font>
    662. 

  662.                 (float (* 100 (/ sum (- end start)))))))
    663. 

  663. 

  664. FOO
    665. 

  665. 

  666. * (foo "a" "abcabcabc")
    667. 

  667. 33.33% of the string was inside of a match
    668. 

  668. NIL
    669. 

  669. * (foo "aa|b" "aacabcbbc")
    670. 

  670. 55.56% of the string was inside of a match
    671. 

  671. NIL
    672. 

  672. </pre></blockquote>
    673. 

  673. 

  674. 

  675. 

  676. 

  677. <p><br>[Macro]
    678. 

  678. <br><a class=none name="do-matches-as-strings"><b>do-matches-as-strings</b> <i>(match-var regex target-string <tt>&amp;optional</tt> result-form <tt>&amp;key</tt> start end sharedp) declaration* statement*</i> =&gt; <i>result*</i></a>
    679. 

  679. 

  680. <blockquote><br>
    681. 

  681. Like <a href="#do-matches"><code>DO-MATCHES</code></a> but binds
    682. 

  682. <code><i>match-var</i></code> to the substring of
    683. 

  683. <code><i>target-string</i></code> corresponding to each match in turn. If <code><i>sharedp</i></code> is true, the substrings may share structure with
    684. 

  684. <code><i>target-string</i></code>.
    685. 

  685. <pre>
    686. 

  686. * (defun crossfoot (target-string &amp;key (start 0) (end (length target-string)))
    687. 

  687.     (let ((sum 0))
    688. 

  688.       (do-matches-as-strings (m :digit-class
    689. 

  689.                                          target-string nil
    690. 

  690.                                          :start start :end end)
    691. 

  691.         (incf sum (parse-integer m)))
    692. 

  692.       (if (< sum 10)
    693. 

  693.         sum
    694. 

  694.         (crossfoot (format nil "~A" sum)))))
    695. 

  695. 

  696. CROSSFOOT
    697. 

  697. 

  698. * (crossfoot "bar")
    699. 

  699. 0
    700. 

  700. 

  701. * (crossfoot "a3x")
    702. 

  702. 3
    703. 

  703. 

  704. * (crossfoot "12345")
    705. 

  705. 6
    706. 

  706. </pre>
    707. 

  707. 

  708. Of course, in real life you would do this with <a href="#do-matches"><code>DO-MATCHES</code></a> and use the <code><i>start</i></code> and <code><i>end</i></code> keyword parameters of <a href="http://www.lispworks.com/documentation/HyperSpec/Body/f_parse_.htm"><code>PARSE-INTEGER</code></a>.</blockquote>
    709. 

  709. 

  710. <p><br>[Macro]
    711. 

  711. <br><a class=none name="do-register-groups"><b>do-register-groups</b> <i>var-list (regex target-string <tt>&amp;optional</tt> result-form <tt>&amp;key</tt> start end sharedp) declaration* statement*</i> =&gt; <i>result*</i></a>
    712. 

  712. 

  713. <blockquote><br>
    714. 

  714. Iterates over <code><i>target-string</i></code> and tries to match <code><i>regex</i></code> as often as
    715. 

  715. possible evaluating <code><i>statement*</i></code> with the variables in <code><i>var-list</i></code> bound to the
    716. 

  716. corresponding register groups for each match in turn, i.e. each
    717. 

  717. variable is either bound to a string or to <code>NIL</code>. You can use the same shortcuts and abbreviations as in <a href="#register-groups-bind"><code>REGISTER-GROUPS-BIND</code></a>. The number of
    718. 

  718. variables in <code><i>var-list</i></code> must not be greater than the number of register
    719. 

  719. groups. For each element of
    720. 

  720. <code><i>var-list</i></code> which is <code>NIL</code> there's no binding to the corresponding register
    721. 

  721. group. After the last match, returns <code><i>result-form</i></code> if provided or <code>NIL</code>
    722. 

  722. otherwise. An implicit block named <code>NIL</code> surrounds <code>DO-REGISTER-GROUPS</code>;
    723. 

  723. <code>RETURN</code> may be used to terminate the loop immediately. If <code><i>regex</i></code> matches
    724. 

  724. an empty string, the scan is continued one position behind this
    725. 

  725. match. If <code><i>sharedp</i></code> is true, the substrings may share structure with
    726. 

  726. <code><i>target-string</i></code>.
    727. 

  727. <pre>
    728. 

  728. * (do-register-groups (first second third fourth)
    729. 

  729.       (&quot;((a)|(b)|(c))&quot; &quot;abababc&quot; nil :start 2 :sharedp t)
    730. 

  730.     (print (list first second third fourth)))
    731. 

  731. (&quot;a&quot; &quot;a&quot; NIL NIL) 
    732. 

  732. (&quot;b&quot; NIL &quot;b&quot; NIL) 
    733. 

  733. (&quot;a&quot; &quot;a&quot; NIL NIL) 
    734. 

  734. (&quot;b&quot; NIL &quot;b&quot; NIL) 
    735. 

  735. (&quot;c&quot; NIL NIL &quot;c&quot;)
    736. 

  736. NIL
    737. 

  737. 

  738. * (let (result)
    739. 

  739.     (do-register-groups ((#'parse-integer n) (#'intern sign) whitespace)
    740. 

  740.         (&quot;(\\d+)|(\\+|-|\\*|/)|(\\s+)&quot; &quot;12*15 - 42/3&quot;)
    741. 

  741.       (unless whitespace
    742. 

  742.         (push (or n sign) result)))
    743. 

  743.     (nreverse result))
    744. 

  744. (12 * 15 - 42 / 3)
    745. 

  745. </pre>
    746. 

  746. </blockquote>
    747. 

  747. 

  748. 

  749. <p><br>[Function]
    750. 

  750. <br><a class=none name="all-matches"><b>all-matches</b> <i>regex target-string <tt>&amp;key</tt> start end</i> =&gt; <i>list</i></a>
    751. 

  751. 

  752. <blockquote><br>
    753. 

  753. Returns a list containing the start and end positions of all matches
    754. 

  754. of <code><i>regex</i></code> against
    755. 

  755. <code><i>target-string</i></code>, i.e. if there are <code>N</code>
    756. 

  756. matches the list contains <code>(* 2 N)</code> elements. If
    757. 

  757. <code><i>regex</i></code> matches an empty string the scan is
    758. 

  758. continued one position behind this match.
    759. 

  759. <pre>
    760. 

  760. * (all-matches "a" "foo bar baz")
    761. 

  761. (5 6 9 10)
    762. 

  762. 

  763. * (all-matches "\\w*" "foo bar baz")
    764. 

  764. (0 3 3 3 4 7 7 7 8 11 11 11)
    765. 

  765. </pre></blockquote>
    766. 

  766. 

  767. 

  768. 

  769. 

  770. <p><br>[Function]
    771. 

  771. <br><a class=none name="all-matches-as-strings"><b>all-matches-as-strings</b> <i>regex target-string <tt>&amp;key</tt> start end sharedp</i> =&gt; <i>list</i></a>
    772. 

  772. 

  773. <blockquote><br>
    774. 

  774. Like <a href="#all-matches"><code>ALL-MATCHES</code></a> but
    775. 

  775. returns a list of substrings instead. If <code><i>sharedp</i></code> is true, the substrings may share structure with
    776. 

  776. <code><i>target-string</i></code>.
    777. 

  777. <pre>
    778. 

  778. * (all-matches-as-strings "a" "foo bar baz")
    779. 

  779. ("a" "a")
    780. 

  780. 

  781. * (all-matches-as-strings "\\w*" "foo bar baz")
    782. 

  782. ("foo" "" "bar" "" "baz" "")
    783. 

  783. </pre></blockquote>
    784. 

  784. 

  785. 

  786. 

  787. 

  788. <h4><a name="splitting" class=none>Splitting and replacing</a></h4>
    789. 

  789. 

  790. 

  791. <p><br>[Function]
    792. 

  792. <br><a class=none name="split"><b>split</b> <i>regex target-string <tt>&amp;key</tt> start end limit with-registers-p omit-unmatched-p sharedp</i> =&gt; <i>list</i></a>
    793. 

  793. 

  794. <blockquote><br>
    795. 

  795. Matches <code><i>regex</i></code> against
    796. 

  796. <code><i>target-string</i></code> as often as possible and returns a
    797. 

  797. list of the substrings between the matches. If
    798. 

  798. <code><i>with-registers-p</i></code> is true, substrings corresponding
    799. 

  799. to matched registers are inserted into the list as well.  If
    800. 

  800. <code><i>omit-unmatched-p</i></code> is true, unmatched registers will
    801. 

  801. simply be left out, otherwise they will show up as
    802. 

  802. <code>NIL</code>. <code><i>limit</i></code> limits the number of
    803. 

  803. elements returned - registers aren't counted. If
    804. 

  804. <code><i>limit</i></code> is <code>NIL</code> (or 0 which is
    805. 

  805. equivalent), trailing empty strings are removed from the result list.
    806. 

  806. If <code><i>regex</i></code> matches an empty string, the scan is
    807. 

  807. continued one position behind this match. If <code><i>sharedp</i></code> is true, the substrings may share structure with
    808. 

  808. <code><i>target-string</i></code>.
    809. 

  809. <p>
    810. 

  810. This function also tries hard to be
    811. 

  811. Perl-compatible - thus the somewhat peculiar behaviour.
    812. 

  812. <pre>
    813. 

  813. * (split "\\s+" "foo   bar baz
    814. 

  814. frob")
    815. 

  815. ("foo" "bar" "baz" "frob")
    816. 

  816. 

  817. * (split "\\s*" "foo bar   baz")
    818. 

  818. ("f" "o" "o" "b" "a" "r" "b" "a" "z")
    819. 

  819. 

  820. * (split "(\\s+)" "foo bar   baz")
    821. 

  821. ("foo" "bar" "baz")
    822. 

  822. 

  823. * (split "(\\s+)" "foo bar   baz" :with-registers-p t)
    824. 

  824. ("foo" " " "bar" "   " "baz")
    825. 

  825. 

  826. * (split "(\\s)(\\s*)" "foo bar   baz" :with-registers-p t)
    827. 

  827. ("foo" " " "" "bar" " " "  " "baz")
    828. 

  828. 

  829. * (split "(,)|(;)" "foo,bar;baz" :with-registers-p t)
    830. 

  830. ("foo" "," NIL "bar" NIL ";" "baz")
    831. 

  831. 

  832. * (split "(,)|(;)" "foo,bar;baz" :with-registers-p t :omit-unmatched-p t)
    833. 

  833. ("foo" "," "bar" ";" "baz")
    834. 

  834. 

  835. * (split ":" "a:b:c:d:e:f:g::")
    836. 

  836. ("a" "b" "c" "d" "e" "f" "g")
    837. 

  837. 

  838. * (split ":" "a:b:c:d:e:f:g::" :limit 1)
    839. 

  839. ("a:b:c:d:e:f:g::")
    840. 

  840. 

  841. * (split ":" "a:b:c:d:e:f:g::" :limit 2)
    842. 

  842. ("a" "b:c:d:e:f:g::")
    843. 

  843. 

  844. * (split ":" "a:b:c:d:e:f:g::" :limit 3)
    845. 

  845. ("a" "b" "c:d:e:f:g::")
    846. 

  846. 

  847. * (split ":" "a:b:c:d:e:f:g::" :limit 1000)
    848. 

  848. ("a" "b" "c" "d" "e" "f" "g" "" "")
    849. 

  849. </pre></blockquote>
    850. 

  850. 

  851. 

  852. 

  853. 

  854. 

  855. <p><br>[Function]
    856. 

  856. <br><a class=none name="regex-replace"><b>regex-replace</b> <i>regex target-string replacement <tt>&amp;key</tt> start end preserve-case simple-calls element-type</i> =&gt; <i>string, matchp</i></a>
    857. 

  857. 

  858. <blockquote><br> Try to match <code><i>target-string</i></code>
    859. 

  859. between <code><i>start</i></code> and <code><i>end</i></code> against
    860. 

  860. <code><i>regex</i></code> and replace the first match with
    861. 

  861. <code><i>replacement</i></code>. Two values are returned; the modified
    862. 

  862. string, and <code>T</code> if <code><i>regex</i></code> matched or
    863. 

  863. <code>NIL</code> otherwise.
    864. 

  864. <p>
    865. 

  865. <code><i>replacement</i></code> can be a string which may contain the
    866. 

  866. special substrings <code>&quot;\&amp;&quot;</code> for the whole
    867. 

  867. match, <code>&quot;\`&quot;</code> for the part of
    868. 

  868. <code><i>target-string</i></code> before the match,
    869. 

  869. <code>&quot;\'&quot;</code> for the part of
    870. 

  870. <code><i>target-string</i></code> after the match,
    871. 

  871. <code>&quot;\N&quot;</code> or <code>&quot;\{N}&quot;</code> for the
    872. 

  872. <code>N</code>th register where <code>N</code> is a positive integer.
    873. 

  873. <p>
    874. 

  874. <code><i>replacement</i></code> can also be a <a
    875. 

  875. href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_f.htm#function_designator">function
    876. 

  876. designator</a> in which case the match will be replaced with the
    877. 

  877. result of calling the function designated by
    878. 

  878. <code><i>replacement</i></code> with the arguments
    879. 

  879. <code><i>target-string</i></code>, <code><i>start</i></code>,
    880. 

  880. <code><i>end</i></code>, <code><i>match-start</i></code>,
    881. 

  881. <code><i>match-end</i></code>, <code><i>reg-starts</i></code>, and
    882. 

  882. <code><i>reg-ends</i></code>. (<code><i>reg-starts</i></code> and
    883. 

  883. <code><i>reg-ends</i></code> are arrays holding the start and end
    884. 

  884. positions of matched registers (or <code>NIL</code>) - the meaning of
    885. 

  885. the other arguments should be obvious.)
    886. 

  886. <p>
    887. 

  887. If <code><i>simple-calls</i></code> is true, a function designated by
    888. 

  888. <code><i>replacement</i></code> will instead be called with the
    889. 

  889. arguments <code><i>match</i></code>, <code><i>register-1</i></code>,
    890. 

  890. ..., <code><i>register-n</i></code> where <code><i>match</i></code> is
    891. 

  891. the whole match as a string and <code><i>register-1</i></code> to
    892. 

  892. <code><i>register-n</i></code> are the matched registers, also as
    893. 

  893. strings (or <code>NIL</code>). Note that these strings share structure with
    894. 

  894. <code><i>target-string</i></code> so you must not modify them.
    895. 

  895. <p>
    896. 

  896. Finally, <code><i>replacement</i></code> can be a list where each
    897. 

  897. element is a string (which will be inserted verbatim), one of the
    898. 

  898. symbols <code>:match</code>, <code>:before-match</code>, or
    899. 

  899. <code>:after-match</code> (corresponding to
    900. 

  900. <code>&quot;\&amp;&quot;</code>, <code>&quot;\`&quot;</code>, and
    901. 

  901. <code>&quot;\'&quot;</code> above), an integer <code>N</code>
    902. 

  902. (representing register <code>(1+&nbsp;N)</code>), or a function
    903. 

  903. designator.
    904. 

  904. <p>
    905. 

  905. If <code><i>preserve-case</i></code> is true (default is
    906. 

  906. <code>NIL</code>), the replacement will try to preserve the case (all
    907. 

  907. upper case, all lower case, or capitalized) of the match. The result
    908. 

  908. will always be a <a
    909. 

  909. href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_f.htm#fresh">fresh</a>
    910. 

  910. string, even if <code><i>regex</i></code> doesn't match.
    911. 

  911. <p>
    912. 

  912. <code><i>element-type</i></code> specifies
    913. 

  913. the <a
    914. 

  914. href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_a.htm#array_element_type">array
    915. 

  915. element type</a> of the string which is returned, the default
    916. 

  916. is <a
    917. 

  917. href="http://www.lispworks.com/documentation/lw50/LWRM/html/lwref-346.htm"><code>LW:SIMPLE-CHAR</code></a>
    918. 

  918. for LispWorks
    919. 

  919. and <a
    920. 

  920. href="http://www.lispworks.com/documentation/HyperSpec/Body/t_ch.htm"><code>CHARACTER</code></a>
    921. 

  921. for other Lisps.
    922. 

  922. <pre>
    923. 

  923. * (regex-replace "fo+" "foo bar" "frob")
    924. 

  924. "frob bar"
    925. 

  925. T
    926. 

  926. 

  927. * (regex-replace "fo+" "FOO bar" "frob")
    928. 

  928. "FOO bar"
    929. 

  929. NIL
    930. 

  930. 

  931. * (regex-replace "(?i)fo+" "FOO bar" "frob")
    932. 

  932. "frob bar"
    933. 

  933. T
    934. 

  934. 

  935. * (regex-replace "(?i)fo+" "FOO bar" "frob" :preserve-case t)
    936. 

  936. "FROB bar"
    937. 

  937. T
    938. 

  938. 

  939. * (regex-replace "(?i)fo+" "Foo bar" "frob" :preserve-case t)
    940. 

  940. "Frob bar"
    941. 

  941. T
    942. 

  942. 

  943. * (regex-replace "bar" "foo bar baz" "[frob (was '\\&' between '\\`' and '\\'')]")
    944. 

  944. "foo [frob (was 'bar' between 'foo ' and ' baz')] baz"
    945. 

  945. T
    946. 

  946. 

  947. * (regex-replace "bar" "foo bar baz"
    948. 

  948.                           '("[frob (was '" :match "' between '" :before-match "' and '" :after-match "')]"))
    949. 

  949. "foo [frob (was 'bar' between 'foo ' and ' baz')] baz"
    950. 

  950. T
    951. 

  951. 

  952. * (regex-replace "(be)(nev)(o)(lent)"
    953. 

  953.                           "benevolent: adj. generous, kind"
    954. 

  954.                           #'(lambda (match &amp;rest registers)
    955. 

  955.                               (format nil "~A [~{~A~^.~}]" match registers))
    956. 

  956.                           :simple-calls t)
    957. 

  957. "benevolent [be.nev.o.lent]: adj. generous, kind"
    958. 

  958. T
    959. 

  959. </pre></blockquote>
    960. 

  960. 

  961. 

  962. <p><br>[Function]
    963. 

  963. <br><a class=none name="regex-replace-all"><b>regex-replace-all</b> <i>regex target-string replacement <tt>&amp;key</tt> start end preserve-case simple-calls element-type</i> =&gt; <i>string, matchp</i></a>
    964. 

  964. 

  965. <blockquote><br>
    966. 

  966. Like <a href="#regex-replace"><code>REGEX-REPLACE</code></a> but replaces all matches.
    967. 

  967. <pre>
    968. 

  968. * (regex-replace-all "(?i)fo+" "foo Fooo FOOOO bar" "frob" :preserve-case t)
    969. 

  969. "frob Frob FROB bar"
    970. 

  970. T
    971. 

  971. 

  972. * (regex-replace-all "(?i)f(o+)" "foo Fooo FOOOO bar" "fr\\1b" :preserve-case t)
    973. 

  973. "froob Frooob FROOOOB bar"
    974. 

  974. T
    975. 

  975. 

  976. * (let ((qp-regex (create-scanner "[\\x80-\\xff]")))
    977. 

  977.     (defun encode-quoted-printable (string)
    978. 

  978.       "Converts 8-bit string to quoted-printable representation."
    979. 

  979.       <font color=orange>;; won't work for Corman Lisp because non-ASCII characters aren't 8-bit there</font>
    980. 

  980.       (flet ((convert (target-string start end match-start match-end reg-starts reg-ends)
    981. 

  981.              (declare (ignore start end match-end reg-starts reg-ends))
    982. 

  982.              (format nil "=~2,'0x" (char-code (char target-string match-start)))))
    983. 

  983.         (regex-replace-all qp-regex string #'convert))))
    984. 

  984. Converted ENCODE-QUOTED-PRINTABLE.
    985. 

  985. ENCODE-QUOTED-PRINTABLE
    986. 

  986. 

  987. * (encode-quoted-printable "F&ecirc;te S&oslash;rensen na&iuml;ve H&uuml;hner Stra&szlig;e")
    988. 

  988. "F=EAte S=F8rensen na=EFve H=FChner Stra=DFe"
    989. 

  989. T
    990. 

  990. 

  991. * (let ((url-regex (create-scanner "[^a-zA-Z0-9_\\-.]")))
    992. 

  992.     (defun url-encode (string)
    993. 

  993.       "URL-encodes a string."
    994. 

  994.       <font color=orange>;; won't work for Corman Lisp because non-ASCII characters aren't 8-bit there</font>
    995. 

  995.       (flet ((convert (target-string start end match-start match-end reg-starts reg-ends)
    996. 

  996.              (declare (ignore start end match-end reg-starts reg-ends))
    997. 

  997.              (format nil "%~2,'0x" (char-code (char target-string match-start)))))
    998. 

  998.         (regex-replace-all url-regex string #'convert))))
    999. 

  999. Converted URL-ENCODE.
    1000. 

  1000. URL-ENCODE
    1001. 

  1001. 

  1002. * (url-encode "F&ecirc;te S&oslash;rensen na&iuml;ve H&uuml;hner Stra&szlig;e")
    1003. 

  1003. "F%EAte%20S%F8rensen%20na%EFve%20H%FChner%20Stra%DFe"
    1004. 

  1004. T
    1005. 

  1005. 

  1006. * (defun how-many (target-string start end match-start match-end reg-starts reg-ends)
    1007. 

  1007.     (declare (ignore start end match-start match-end))
    1008. 

  1008.     (format nil "~A" (- (svref reg-ends 0)
    1009. 

  1009.                         (svref reg-starts 0))))
    1010. 

  1010. HOW-MANY
    1011. 

  1011. 

  1012. * (regex-replace-all "{(.+?)}"
    1013. 

  1013.                               "foo{...}bar{.....}{..}baz{....}frob"
    1014. 

  1014.                               (list "[" 'how-many " dots]"))
    1015. 

  1015. "foo[3 dots]bar[5 dots][2 dots]baz[4 dots]frob"
    1016. 

  1016. T
    1017. 

  1017. 

  1018. * (let ((qp-regex (create-scanner "[\\x80-\\xff]")))
    1019. 

  1019.     (defun encode-quoted-printable (string)
    1020. 

  1020.       "Converts 8-bit string to quoted-printable representation.
    1021. 

  1021. Version using SIMPLE-CALLS keyword argument."
    1022. 

  1022.       <font color=orange>;; ;; won't work for Corman Lisp because non-ASCII characters aren't 8-bit there</font>
    1023. 

  1023.       (flet ((convert (match)
    1024. 

  1024.                (format nil "=~2,'0x" (char-code (char match 0)))))
    1025. 

  1025.         (regex-replace-all qp-regex string #'convert
    1026. 

  1026.                                     :simple-calls t))))
    1027. 

  1027. 

  1028. Converted ENCODE-QUOTED-PRINTABLE.
    1029. 

  1029. ENCODE-QUOTED-PRINTABLE
    1030. 

  1030. 

  1031. * (encode-quoted-printable "F&ecirc;te S&oslash;rensen na&iuml;ve H&uuml;hner Stra&szlig;e")
    1032. 

  1032. "F=EAte S=F8rensen na=EFve H=FChner Stra=DFe"
    1033. 

  1033. T
    1034. 

  1034. 

  1035. * (defun how-many (match first-register)
    1036. 

  1036.     (declare (ignore match))
    1037. 

  1037.     (format nil "~A" (length first-register)))
    1038. 

  1038. HOW-MANY
    1039. 

  1039. 

  1040. * (regex-replace-all "{(.+?)}"
    1041. 

  1041.                               "foo{...}bar{.....}{..}baz{....}frob"
    1042. 

  1042.                               (list "[" 'how-many " dots]")
    1043. 

  1043.                               :simple-calls t)
    1044. 

  1044. 

  1045. "foo[3 dots]bar[5 dots][2 dots]baz[4 dots]frob"
    1046. 

  1046. T
    1047. 

  1047. </pre></blockquote>
    1048. 

  1048. 

  1049. <h4><a name="modify" class=none>Modifying scanner behaviour</a></h4>
    1050. 

  1050. 

  1051. <p><br>[Special variable]
    1052. 

  1052. <br><a class=none name="*property-resolver*"><b>*property-resolver*</b></a>
    1053. 

  1053. 

  1054. </p><blockquote><br> This is the designator for a function responsible
    1055. 

  1055. for resolving named properties like <code>\p{Number}</code>.  If
    1056. 

  1056. CL-PPCRE encounters a <code>\p</code> or a <code>\P</code> it expects
    1057. 

  1057. to see an opening curly brace immediately afterwards and will then
    1058. 

  1058. read everything following that brace until it sees a closing curly
    1059. 

  1059. brace.  The resolver function will be called with this string and must
    1060. 

  1060. return a corresponding unary test function which accepts a character
    1061. 

  1061. as its argument and returns a true value if and only if the character
    1062. 

  1062. has the named property.  If the resolver returns <code>NIL</code>
    1063. 

  1063. instead, it signals that a property of that name is unknown.
    1064. 

  1064. <pre>
    1065. 

  1065. * (labels ((char-code-odd-p (char)
    1066. 

  1066.              (oddp (char-code char)))
    1067. 

  1067.            (char-code-even-p (char)
    1068. 

  1068.              (evenp (char-code char)))
    1069. 

  1069.            (resolver (name)
    1070. 

  1070.              (cond ((string= name "odd") #'char-code-odd-p)
    1071. 

  1071.                    ((string= name "even") #'char-code-even-p)
    1072. 

  1072.                    ((string= name "true") (constantly t))
    1073. 

  1073.                    (t (error "Can't resolve ~S." name)))))
    1074. 

  1074.     (let ((*property-resolver* #'resolver))
    1075. 

  1075.       <font color=orange>;; quiz question - why do we need CREATE-SCANNER here?</font>
    1076. 

  1076.       (list (regex-replace-all (create-scanner "\\p{odd}") "abcd" "+")
    1077. 

  1077.             (regex-replace-all (create-scanner "\\p{even}") "abcd" "+")
    1078. 

  1078.             (regex-replace-all (create-scanner "\\p{true}") "abcd" "+"))))
    1079. 

  1079. ("+b+d" "a+c+" "++++")
    1080. 

  1080. </pre>
    1081. 

  1081. If the value
    1082. 

  1082. of <a href="#*property-resolver*"><code>*PROPERTY-RESOLVER*</code></a>
    1083. 

  1083. is <code>NIL</code> (which is the default), <code>\p</code> and <code>\P</code> in regex
    1084. 

  1084. strings will simply be treated like <code>p</code> or <code>P</code>
    1085. 

  1085. as in CL-PPCRE&nbsp;1.4.1 and earlier.  Note that this does not affect
    1086. 

  1086. the validity of <code>(:PROPERTY&nbsp;&lt;<i>name</i>&gt;)</code>
    1087. 

  1087. parts in <a href="#create-scanner2">S-expression syntax</a>.
    1088. 

  1088. </blockquote>
    1089. 

  1089. 

  1090. 

  1091. <p><br>[Accessor]
    1092. 

  1092. <br><a class="none" name="parse-tree-synonym"><b>parse-tree-synonym</b> <i>symbol</i> =&gt; <i>parse-tree</i>
    1093. 

  1093. <br><tt>(setf (</tt><b>parse-tree-synonym</b> <i>symbol</i><tt>)</tt> <i>new-parse-tree</i><tt>)</tt></a>
    1094. 

  1094. 

  1095. </p><blockquote><br>
    1096. 

  1096. Any symbol (unless it's a keyword with a special meaning in parse
    1097. 

  1097. trees) can be made a "synonym", i.e. an abbreviation, for another parse
    1098. 

  1098. tree by this accessor. <code>PARSE-TREE-SYNONYM</code> returns <code>NIL</code> if <code><i>symbol</i></code> isn't a synonym yet.
    1099. 

  1099. <pre>
    1100. 

  1100. * (parse-string "a*b+")
    1101. 

  1101. (:SEQUENCE (:GREEDY-REPETITION 0 NIL #\a) (:GREEDY-REPETITION 1 NIL #\b))
    1102. 

  1102. 

  1103. * (defun my-repetition (char min)
    1104. 

  1104.     `(:greedy-repetition ,min nil ,char))
    1105. 

  1105. MY-REPETITION
    1106. 

    1107. 

  1107. * (setf (parse-tree-synonym 'a*) (my-repetition #\a 0))
    1108. 

  1108. (:GREEDY-REPETITION 0 NIL #\a)
    1109. 

    1110. 

  1110. * (setf (parse-tree-synonym 'b+) (my-repetition #\b 1))
    1111. 

  1111. (:GREEDY-REPETITION 1 NIL #\b)
    1112. 

    1113. 

  1113. * (let ((scanner (create-scanner '(:sequence a* b+))))
    1114. 

  1114.     (dolist (string '("ab" "b" "aab" "a" "x"))
    1115. 

  1115.       (print (scan scanner string)))
    1116. 

  1116.     (values))
    1117. 

  1117. 0
    1118. 

  1118. 0
    1119. 

  1119. 0
    1120. 

  1120. NIL
    1121. 

  1121. NIL
    1122. 

    1123. 

  1123. * (parse-tree-synonym 'a*)
    1124. 

  1124. (:GREEDY-REPETITION 0 NIL #\a)
    1125. 

    1126. 

  1126. * (parse-tree-synonym 'a+)
    1127. 

  1127. NIL
    1128. 

  1128. </pre></blockquote>
    1129. 

    1130. 

  1130. <p><br>[Macro]
    1131. 

  1131. <br><a class="none" name="define-parse-tree-synonym"><b>define-parse-tree-synonym</b> <i>name parse-tree</i> =&gt; <i>parse-tree</i></a>
    1132. 

    1133. 

  1133. </p><blockquote><br>
    1134. 

  1134. This is a convenience macro for parse tree synonyms defined as
    1135. 

    1136. 

  1136. <pre>
    1137. 

  1137. (defmacro define-parse-tree-synonym (name parse-tree)
    1138. 

  1138.   `(eval-when (:compile-toplevel :load-toplevel :execute)
    1139. 

  1139.      (setf (parse-tree-synonym ',name) ',parse-tree)))
    1140. 

  1140. </pre>
    1141. 

  1141. 

  1142. so you can write code like this:
    1143. 

  1143. 

  1144. <pre>
    1145. 

  1145. (define-parse-tree-synonym a-z
    1146. 

  1146.   (:char-class (:range #\a #\z) (:range #\A #\Z)))
    1147. 

  1147. 

  1148. (define-parse-tree-synonym a-z*
    1149. 

  1149.   (:greedy-repetition 0 nil a-z))
    1150. 

  1150. 

  1151. (defun ascii-char-tester (string)
    1152. 

  1152.   (scan '(:sequence :start-anchor a-z* :end-anchor)
    1153. 

  1153.         string))
    1154. 

  1154. </pre></blockquote>
    1155. 

  1155. 

  1156. <p><br>[Special variable]
    1157. 

  1157. <br><a class=none name="*regex-char-code-limit*"><b>*regex-char-code-limit*</b></a>
    1158. 

  1158. 

  1159. <blockquote><br>This variable controls whether scanners take into
    1160. 

  1160. account all characters of your CL implementation or only those
    1161. 

  1161. the <a
    1162. 

  1162. href="http://www.lispworks.com/documentation/HyperSpec/Body/f_char_c.htm#char-code"><code>CHAR-CODE</code></a>
    1163. 

  1163. of which is not larger than its value. The default is
    1164. 

  1164. <a href="http://www.lispworks.com/documentation/HyperSpec/Body/v_char_c.htm"><code>CHAR-CODE-LIMIT</code></a>,
    1165. 

  1165. and you might see significant speed and space improvements during
    1166. 

  1166. scanner <em>creation</em> if, say, your target strings only
    1167. 

  1167. contain <a href="http://czyborra.com/charsets/iso8859.html">ISO-8859-1</a>
    1168. 

  1168. characters and you're using a Lisp implementation
    1169. 

  1169. where <code>CHAR-CODE-LIMIT</code> has a value much higher
    1170. 

  1170. than&nbsp;256. The <a href="#test">test suite</a> will automatically
    1171. 

  1171. set <code>*REGEX-CHAR-CODE-LIMIT*</code> to 256 while you're running
    1172. 

  1172. the default test.
    1173. 

  1173. <p>
    1174. 

  1174. Note: Due to the nature of <a href="http://www.lispworks.com/documentation/HyperSpec/Body/s_ld_tim.htm"><code>LOAD-TIME-VALUE</code></a> and the <a
    1175. 

  1175. href="#compiler-macro">compiler macro for <code>SCAN</code> and other functions</a>, some
    1176. 

  1176. scanners might be created in a <a
    1177. 

  1177. href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_n.htm#null_lexical_environment">null
    1178. 

  1178. lexical environment</a> at load time or at compile time so be careful
    1179. 

  1179. to which value <code>*REGEX-CHAR-CODE-LIMIT*</code> is bound at that
    1180. 

  1180. time. The default value should always yield correct results unless you
    1181. 

  1181. play dirty tricks with implementation-dependent behaviour, though.</blockquote>
    1182. 

  1182. 

  1183. <p><br>[Special variable]
    1184. 

  1184. <br><a class=none name="*use-bmh-matchers*"><b>*use-bmh-matchers*</b></a>
    1185. 

  1185. 

  1186. <blockquote><br>Usually, the scanners created
    1187. 

  1187. by <a href="#create-scanner"><code>CREATE-SCANNER</code></a> (or
    1188. 

  1188. implicitly by other functions and macros) will use the standard
    1189. 

  1189. function <a href="http://www.lispworks.com/documentation/HyperSpec/Body/f_search.htm"><code>SEARCH</code></a>
    1190. 

  1190. to check for constant strings at the start or end of the regular
    1191. 

  1191. expression.  If <code>*USE-BMH-MATCHERS*</code> is true (the default
    1192. 

  1192. is <code>NIL</code>),
    1193. 

  1193. fast <a href="http://www-igm.univ-mlv.fr/~lecroq/string/node18.html">Boyer-Moore-Horspool
    1194. 

  1194. matchers</a> will be used instead.  This will usually be faster but
    1195. 

  1195. can make the scanners considerably bigger.  Per BMH matcher - there
    1196. 

  1196. can be up to two per scanner - a fixnum array of
    1197. 

  1197. size <a href="#*regex-char-code-limit*"><code>*REGEX-CHAR-CODE-LIMIT*</code></a>
    1198. 

  1198. is allocated and closed over.
    1199. 

  1199. <p>
    1200. 

  1200. Note: Due to the nature of <a href="http://www.lispworks.com/documentation/HyperSpec/Body/s_ld_tim.htm"><code>LOAD-TIME-VALUE</code></a> and the <a
    1201. 

  1201. href="#compiler-macro">compiler macro for <code>SCAN</code> and other functions</a>, some
    1202. 

  1202. scanners might be created in a <a
    1203. 

  1203. href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_n.htm#null_lexical_environment">null
    1204. 

  1204. lexical environment</a> at load time or at compile time so be careful
    1205. 

  1205. to which value <code>*USE-BMH-MATCHERS*</code> is bound at that
    1206. 

  1206. time.</blockquote>
    1207. 

  1207. 

  1208. <p><br>[Special variable]<br><a class=none name='*optimize-char-classes*'><b>*optimize-char-classes*</b></a>
    1209. 

  1209. <blockquote><br>
    1210. 

  1210. Whether character classes should be compiled into look-ups into <em>O(1)</em>
    1211. 

  1211. data structures.  This is usually fast but will be costly in terms of
    1212. 

  1212. scanner creation time and might be costly in terms of size if
    1213. 

  1213. <a href="#*regex-char-code-limit*"><code>*REGEX-CHAR-CODE-LIMIT*</code></a>
    1214. 

  1214. is high.  This value will be used as the <code><i>kind</i></code>
    1215. 

  1215. keyword argument
    1216. 

  1216. to <a href="#create-optimized-test-function"><code>CREATE-OPTIMIZED-TEST-FUNCTION</code></a>
    1217. 

  1217. - see there for the possible non-<code>NIL</code> values.  The default
    1218. 

  1218. value (<code>NIL</code>) should usually be fine unless you're sure
    1219. 

  1219. that you absolutely have to optimize some character classes for speed.
    1220. 

  1220. <p>
    1221. 

  1221. Note: Due to the nature
    1222. 

  1222. of <a href="http://www.lispworks.com/documentation/HyperSpec/Body/s_ld_tim.htm"><code>LOAD-TIME-VALUE</code></a>
    1223. 

  1223. and the <a href="#compiler-macro">compiler macro for <code>SCAN</code>
    1224. 

  1224. and other functions</a>, some scanners might be created in
    1225. 

  1225. a <a href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_n.htm#null_lexical_environment">null
    1226. 

  1226. lexical environment</a> at load time or at compile time so be careful
    1227. 

  1227. to which value <code>*OPTIMIZE-CHAR-CLASSES*</code> is bound at that
    1228. 

  1228. time.
    1229. 

  1229. </blockquote>
    1230. 

  1230. 

  1231. <p><br>[Special variable]
    1232. 

  1232. <br><a class=none name="*allow-quoting*"><b>*allow-quoting*</b></a>
    1233. 

  1233. 

  1234. <blockquote><br>
    1235. 

  1235. If this value is <em>true</em> (the default is <code>NIL</code>),
    1236. 

  1236. CL-PPCRE will support <code>\Q</code> and <code>\E</code> in regex
    1237. 

  1237. strings to quote (disable) metacharacters. Note that this entails a
    1238. 

  1238. slight performance penalty when creating scanners because (a copy of) the regex
    1239. 

  1239. string is modified (probably more than once) before it
    1240. 

  1240. is fed to the parser. Also, the parser's <a
    1241. 

  1241. href="#ppcre-syntax-error">syntax error messages</a> will complain
    1242. 

  1242. about the converted string and not about the original regex string.
    1243. 

  1243. 

  1244. <pre>
    1245. 

  1245. * (scan &quot;^a+$&quot; &quot;a+&quot;)
    1246. 

  1246. NIL
    1247. 

  1247. 

  1248. * (let ((*allow-quoting* t))
    1249. 

  1249.     <font color=orange>;;we use CREATE-SCANNER because of Lisps like SBCL that don't have an interpreter</font>
    1250. 

  1250.     (scan (create-scanner &quot;^\\Qa+\\E$&quot;) &quot;a+&quot;))
    1251. 

  1251. 0
    1252. 

  1252. 2
    1253. 

  1253. #()
    1254. 

  1254. #()
    1255. 

  1255. 

  1256. * (let ((*allow-quoting* t))
    1257. 

  1257.     (scan (create-scanner &quot;\\Qa()\\E(?#comment\\Q)a**b&quot;) &quot;()ab&quot;))
    1258. 

  1258. 

  1259. Quantifier '*' not allowed at position 19 in string &quot;a\\(\\)(?#commentQ)a**b&quot;
    1260. 

  1260. </pre>
    1261. 

  1261. 

  1262. Note how in the last example the regex string in the error message is
    1263. 

  1263. different from the first argument to the <code>SCAN</code>
    1264. 

  1264. function. Also note that the second example might be easier to
    1265. 

  1265. understand (and Lisp-ier) if you write it like this:
    1266. 

  1266. 

  1267. <pre>
    1268. 

  1268. * (scan '(:sequence :start-anchor
    1269. 

  1269.                     &quot;a+&quot; <font color=orange>;; no quoting necessary</font>
    1270. 

  1270.                     :end-anchor)
    1271. 

  1271.         &quot;a+&quot;)
    1272. 

  1272. 0
    1273. 

  1273. 2
    1274. 

  1274. #()
    1275. 

  1275. #()
    1276. 

  1276. </pre>
    1277. 

  1277. 

  1278. Make sure you also read <a href="#quote">the relevant section</a> in &quot;<a href="#bugs">Bugs and problems</a>.&quot;
    1279. 

  1279. <p>
    1280. 

  1280. Note: Due to the nature of <a href="http://www.lispworks.com/documentation/HyperSpec/Body/s_ld_tim.htm"><code>LOAD-TIME-VALUE</code></a> and the <a
    1281. 

  1281. href="#compiler-macro">compiler macro for <code>SCAN</code> and other functions</a>, some
    1282. 

  1282. scanners might be created in a <a
    1283. 

  1283. href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_n.htm#null_lexical_environment">null
    1284. 

  1284. lexical environment</a> at load time or at compile time so be careful
    1285. 

  1285. to which value <code>*ALLOW-QUOTING*</code> is bound at that
    1286. 

  1286. time.</blockquote>
    1287. 

  1287. 

  1288. </blockquote>
    1289. 

  1289. 

  1290. <p><br>[Special variable]
    1291. 

  1291. <br><a class=none name="*allow-named-registers*"><b>*allow-named-registers*</b></a>
    1292. 

  1292. 

  1293. <blockquote><br>
    1294. 

  1294. If this value is <em>true</em> (the default is <code>NIL</code>),
    1295. 

  1295. CL-PPCRE will support <code>(?<i>&lt;name&gt;"&lt;regex&gt;"</i>)</code> and <code>\k<i>&lt;name&gt;</i></code> in regex
    1296. 

  1296. strings to provide named registers and back-references as in <a href="http://www.franz.com/support/documentation/7.0/doc/regexp.htm#regexp-new-capturing-2">AllegroCL</a>. <code><i>name</i></code> is has to start with a letter and can contain only alphanumeric characters or minus sign.  Names of registers are matched case-sensitively.
    1297. 

  1297. The <a href="#create-scanner2">parse tree syntax</a> is not affected by the <code>*ALLOW-NAMED-REGISTERS*</code> switch, <code>:NAMED-REGISTER</code> and <code>:BACK-REFERENCE</code> forms are always resolved as expected. There are also no restrictions on register names in this syntax except that they have to be strings.
    1298. 

  1298. 

  1299. <pre>
    1300. 

  1300. <font color=orange>;; Perl compatible mode (*ALLOW-NAMED-REGISTERS* is NIL)</font>
    1301. 

  1301. * (create-scanner "(?&lt;reg&gt;.*)")
    1302. 

  1302. Character 'r' may not follow '(?&lt' at position 3 in string "(?&lt;reg&gt;)"
    1303. 

  1303. 

  1304. <font color=orange>;; just unescapes "\\k"</font>
    1305. 

  1305. * (parse-string "\\k&lt;reg&gt;")
    1306. 

  1306. "k&lt;reg&gt;"
    1307. 

  1307. 

  1308. * (setq *allow-named-registers* t)
    1309. 

  1309. T
    1310. 

  1310. 

  1311. * (create-scanner "((?&lt;small&gt;[a-z]*)(?&lt;big&gt;[A-Z]*))")
    1312. 

  1312. #&LT;CLOSURE (LAMBDA (STRING CL-PPCRE::START CL-PPCRE::END)) {AD75BFD}&gt;
    1313. 

  1313. (NIL "small" "big")
    1314. 

  1314. 

  1315. <font color=orange>;; the scanner doesn't capture any information about named groups -
    1316. 

  1316. ;; you have to store the second value returned from CREATE-SCANNER yourself</font>
    1317. 

  1317. * (scan * "aaaBBB")
    1318. 

  1318. 0
    1319. 

  1319. 6
    1320. 

  1320. #(0 0 3)
    1321. 

  1321. #(6 3 6)
    1322. 

  1322. 

  1323. <font color=orange>;; parse tree syntax</font>
    1324. 

  1324. * (parse-string "((?&lt;small&gt;[a-z]*)(?&lt;big&gt;[A-Z]*))")
    1325. 

  1325. (:REGISTER
    1326. 

  1326.  (:SEQUENCE
    1327. 

  1327.   (:NAMED-REGISTER "small"
    1328. 

  1328.    (:GREEDY-REPETITION 0 NIL (:CHAR-CLASS (:RANGE #\a #\z))))
    1329. 

  1329.   (:NAMED-REGISTER "big"
    1330. 

  1330.    (:GREEDY-REPETITION 0 NIL (:CHAR-CLASS (:RANGE #\A #\Z))))))
    1331. 

  1331. 

  1332. * (create-scanner *)
    1333. 

  1333. #&lt;CLOSURE (LAMBDA (STRING CL-PPCRE::START CL-PPCRE::END)) {B158E3D}&gt;
    1334. 

  1334. (NIL "small" "big")
    1335. 

  1335. 

  1336. <font color=orange>;; multiple-choice back-reference</font>
    1337. 

  1337. * (scan "^(?&lt;reg&gt;[ab])(?&lt;reg&gt;[12])\\k&lt;reg&gt;\\k&lt;reg&gt;$" "a1aa")
    1338. 

  1338. 0
    1339. 

  1339. 4
    1340. 

  1340. #(0 1)
    1341. 

  1341. #(1 2)
    1342. 

  1342. 

  1343. * (scan "^(?&lt;reg&gt;[ab])(?&lt;reg&gt;[12])\\k&lt;reg&gt;\\k&lt;reg&gt;$" "a22a")
    1344. 

  1344. 0
    1345. 

  1345. 4
    1346. 

  1346. #(0 1)
    1347. 

  1347. #(1 2)
    1348. 

  1348. 

  1349. <font color=orange>;; demonstrating most-recently-seen-register-first property of back-reference;
    1350. 

  1350. ;; "greedy" regex (analogous to "aa?")</font>
    1351. 

  1351. * (scan "^(?&lt;reg&gt;)(?&lt;reg&gt;a)(\\k&lt;reg&gt;)" "a")
    1352. 

  1352. 0
    1353. 

  1353. 1
    1354. 

  1354. #(0 0 1)
    1355. 

  1355. #(0 1 1)
    1356. 

  1356. 

  1357. * (scan "^(?&lt;reg&gt;)(?&lt;reg&gt;a)(\\k&lt;reg&gt;)" "aa")
    1358. 

  1358. 0
    1359. 

  1359. 2
    1360. 

  1360. #(0 0 1)
    1361. 

  1361. #(0 1 2)
    1362. 

  1362. 

  1363. <font color=orange>;; switched groups
    1364. 

  1364. ;; "lazy" regex (analogous to "aa??")</font>
    1365. 

  1365. * (scan "^(?&lt;reg&gt;a)(?&lt;reg&gt;)(\\k&lt;reg&gt;)" "a")
    1366. 

  1366. 0
    1367. 

  1367. 1
    1368. 

  1368. #(0 1 1)
    1369. 

  1369. #(1 1 1)
    1370. 

  1370. 

  1371. <font color=orange>;; scanner ignores the second "a"</font>
    1372. 

  1372. * (scan "^(?&lt;reg&gt;a)(?&lt;reg&gt;)(\\k&lt;reg&gt;)" "aa")
    1373. 

  1373. 0
    1374. 

  1374. 1
    1375. 

  1375. #(0 1 1)
    1376. 

  1376. #(1 1 1)
    1377. 

  1377. 

  1378. <font color=orange>;; "aa" will be matched only when forced by adding "$" at the end</font>
    1379. 

  1379. * (scan "^(?&lt;reg&gt;a)(?&lt;reg&gt;)(\\k&lt;reg&gt;)$" "aa")
    1380. 

  1380. 0
    1381. 

  1381. 2
    1382. 

  1382. #(0 1 1)
    1383. 

  1383. #(1 1 2)
    1384. 

  1384. </pre>
    1385. 

  1385. Note: Due to the nature of <a href="http://www.lispworks.com/documentation/HyperSpec/Body/s_ld_tim.htm"><code>LOAD-TIME-VALUE</code></a> and the <a
    1386. 

  1386. href="#compiler-macro">compiler macro for <code>SCAN</code> and other functions</a>, some
    1387. 

  1387. scanners might be created in a <a
    1388. 

  1388. href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_n.htm#null_lexical_environment">null
    1389. 

  1389. lexical environment</a> at load time or at compile time so be careful
    1390. 

  1390. to which value <code>*ALLOW-NAMED-REGISTERS*</code> is bound at that
    1391. 

  1391. time.</blockquote>
    1392. 

  1392. </blockquote>
    1393. 

  1393. 

  1394. <h4><a name="misc" class=none>Miscellaneous</a></h4>
    1395. 

  1395. 

  1396. <p><br>[Function]
    1397. 

  1397. <br><a class=none name="parse-string"><b>parse-string</b> <i>string</i> =&gt; <i>parse-tree</i></a>
    1398. 

  1398. 

  1399. <blockquote><br> Converts the <a href="#create-scanner">regex
    1400. 

  1400. string</a> <code><i>string</i></code> into a <a href="#create-scanner2">parse tree</a>.
    1401. 

  1401. Note that the result is usually one possible way of creating an
    1402. 

  1402. equivalent parse tree and not necessarily the "canonical" one.
    1403. 

  1403. Specifically, the parse tree might contain redundant parts which are
    1404. 

  1404. supposed to be excised when a scanner is created.
    1405. 

  1405. </blockquote>
    1406. 

  1406. 

  1407. <p><br>[Function]<br><a class=none name='create-optimized-test-function'><b>create-optimized-test-function</b> <i>test-function <tt>&amp;key</tt> start end kind</i> =&gt; <i>function</i></a>
    1408. 

  1408. <blockquote><br>
    1409. 

  1409. 

  1410. Given a unary test function <code><i>test-function</i></code> which is
    1411. 

  1411. applicable to characters returns a function which yields the same
    1412. 

  1412. boolean results for all characters with character codes
    1413. 

  1413. from <code><i>start</i></code> to (excluding) <code><i>end</i></code>.
    1414. 

  1414. If <code><i>kind</i></code>
    1415. 

  1415. is <code>NIL</code>, <code><i>test-function</i></code> will simply be
    1416. 

  1416. returned.  Otherwise, <code><i>kind</i></code> should be one of:
    1417. 

  1417. <dl>
    1418. 

  1418. <dt><code>:HASH-TABLE</code></dt>
    1419. 

  1419. <dd>The function builds a hash table representing all characters which
    1420. 

  1420. satisfy the test and returns a closure which checks if a character is
    1421. 

  1421. in that hash table.</dd>
    1422. 

  1422. <dt><code>:CHARSET</code></dt>
    1423. 

  1423. <dd>Instead of a hash table the function uses a &quot;charset&quot;
    1424. 

  1424. which is a data structure using non-linear hashing and optimized to
    1425. 

  1425. represent (sparse) sets of characters in a fast and space-efficient
    1426. 

  1426. way (contributed by Nikodemus Siivola).</dd>
    1427. 

  1427. <dt><code>:CHARMAP</code></dt>
    1428. 

  1428. <dd>Instead of a hash table the function uses a bit vector to
    1429. 

  1429. represent the set of characters.</dd>
    1430. 

  1430. </dl>
    1431. 

  1431. You can also use <code>:HASH-TABLE*</code> or <code>:CHARSET*</code>
    1432. 

  1432. which are like <code>:HASH-TABLE</code> and <code>:CHARSET</code> but
    1433. 

  1433. use the complement of the set if the set contains more than half of
    1434. 

  1434. all characters between <code><i>start</i></code>
    1435. 

  1435. and <code><i>end</i></code>.  This saves space but needs an additional
    1436. 

  1436. pass across all characters to create the data structure.  There is no
    1437. 

  1437. corresponding <code>:CHARMAP*</code> <code><i>kind</i></code> as the bit vectors are
    1438. 

  1438. already created to cover the smallest possible interval which contains
    1439. 

  1439. either the set or its complement.
    1440. 

  1440. <p>
    1441. 

  1441. See also <a href="#*optimize-char-classes*"><code>*OPTIMIZE-CHAR-CLASSES*</code></a>.
    1442. 

  1442. </blockquote>
    1443. 

  1443. 

  1444. <p><br>[Function]
    1445. 

  1445. <br><a class=none name="quote-meta-chars"><b>quote-meta-chars</b> <i>string</i> =&gt; <i>string'</i></a>
    1446. 

    1447. 

  1447. <blockquote><br>
    1448. 

  1448. This is a simple utility function used when <a
    1449. 

  1449. href="#*allow-quoting*"><code>*ALLOW-QUOTING*</code></a> is
    1450. 

  1450. <em>true</em>. It returns a string <code>STRING'</code> where all
    1451. 

  1451. non-word characters (everything except ASCII characters, digits and
    1452. 

  1452. underline) of <code>STRING</code> are quoted by prepending a
    1453. 

  1453. backslash similar to Perl's <code>quotemeta</code> function. It always returns a <a
    1454. 

  1454. href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_f.htm#fresh">fresh</a>
    1455. 

  1455. string.
    1456. 

  1456. <pre>
    1457. 

  1457. * (quote-meta-chars &quot;[a-z]*&quot;)
    1458. 

  1458. &quot;\\[a\\-z\\]\\*&quot;
    1459. 

  1459. </pre></blockquote>
    1460. 

  1460. 

  1461. <p><br>[Function]
    1462. 

  1462. <br><a class=none name="regex-apropos"><b>regex-apropos</b> <i>regex <tt>&amp;optional</tt> packages <tt>&amp;key</tt> case-insensitive</i> =&gt; <i>list</i></a>
    1463. 

  1463. 

  1464. <blockquote><br>
    1465. 

  1465. Like <a
    1466. 

  1466. href="http://www.lispworks.com/documentation/HyperSpec/Body/f_apropo.htm"><code>APROPOS</code></a>
    1467. 

  1467. but searches for interned symbols which match the regular expression
    1468. 

  1468. <code><i>regex</i></code>. The output is implementation-dependent. If
    1469. 

  1469. <code><i>case-insensitive</i></code> is true (which is the default)
    1470. 

  1470. and <code><i>regex</i></code> isn't already a scanner, a
    1471. 

  1471. case-insensitive scanner is used.
    1472. 

  1472. <p>
    1473. 

  1473. Here are examples for CMUCL:
    1474. 

  1474. 

  1475. <pre>
    1476. 

  1476. * *package*
    1477. 

  1477. #&lt;The COMMON-LISP-USER package, 16/21 internal, 0/9 external&gt;
    1478. 

  1478. 

  1479. * (defun foo (n &amp;optional (k 0)) (+ 3 n k))
    1480. 

  1480. FOO
    1481. 

  1481. 

  1482. * (defparameter foo "bar")
    1483. 

  1483. FOO
    1484. 

  1484. 

  1485. * (defparameter |foobar| 42)
    1486. 

  1486. |foobar|
    1487. 

  1487. 

  1488. * (defparameter fooboo 43)
    1489. 

  1489. FOOBOO
    1490. 

  1490. 

  1491. * (defclass frobar () ())
    1492. 

  1492. #&lt;STANDARD-CLASS FROBAR {4874E625}&gt;
    1493. 

  1493. 

  1494. * (regex-apropos "foo(?:bar)?")
    1495. 

  1495. FOO [variable] value: "bar"
    1496. 

  1496.     [compiled function] (N &amp;OPTIONAL (K 0))
    1497. 

  1497. FOOBOO [variable] value: 43
    1498. 

  1498. |foobar| [variable] value: 42
    1499. 

  1499. 

  1500. * (regex-apropos "(?:foo|fro)bar")
    1501. 

  1501. PCL::|COMMON-LISP-USER::FROBAR class predicate| [compiled closure]
    1502. 

  1502. FROBAR [class] #&lt;STANDARD-CLASS FROBAR {4874E625}&gt;
    1503. 

  1503. |foobar| [variable] value: 42
    1504. 

  1504. 

  1505. * (regex-apropos "(?:foo|fro)bar" 'cl-user)
    1506. 

  1506. FROBAR [class] #&lt;STANDARD-CLASS FROBAR {4874E625}&gt;
    1507. 

  1507. |foobar| [variable] value: 42
    1508. 

  1508. 

  1509. * (regex-apropos "(?:foo|fro)bar" '(pcl ext))
    1510. 

  1510. PCL::|COMMON-LISP-USER::FROBAR class predicate| [compiled closure]
    1511. 

  1511. 

  1512. * (regex-apropos "foo")
    1513. 

  1513. FOO [variable] value: "bar"
    1514. 

  1514.     [compiled function] (N &amp;OPTIONAL (K 0))
    1515. 

  1515. FOOBOO [variable] value: 43
    1516. 

  1516. |foobar| [variable] value: 42
    1517. 

  1517. 

  1518. * (regex-apropos "foo" nil :case-insensitive nil)
    1519. 

  1519. |foobar| [variable] value: 42
    1520. 

  1520. </pre></blockquote>
    1521. 

  1521. 

  1522. 

  1523. 

  1524. 

  1525. <p><br>[Function]
    1526. 

  1526. <br><a class=none name="regex-apropos-list"><b>regex-apropos-list</b> <i>regex <tt>&amp;optional</tt> packages <tt>&amp;key</tt> upcase</i> =&gt; <i>list</i></a>
    1527. 

  1527. 

  1528. <blockquote><br>
    1529. 

  1529. Like <a
    1530. 

  1530. href="http://www.lispworks.com/documentation/HyperSpec/Body/f_apropo.htm"><code>APROPOS-LIST</code></a>
    1531. 

  1531. but searches for interned symbols which match the regular expression
    1532. 

  1532. <code><i>regex</i></code>. If <code><i>case-insensitive</i></code> is
    1533. 

  1533. true (which is the default) and <code><i>regex</i></code> isn't
    1534. 

  1534. already a scanner, a case-insensitive scanner is used.
    1535. 

  1535. <p>
    1536. 

  1536. Example (continued from above):
    1537. 

  1537. 

  1538. <pre>
    1539. 

  1539. * (regex-apropos-list &quot;foo(?:bar)?&quot;)
    1540. 

  1540. (|foobar| FOOBOO FOO)
    1541. 

  1541. </pre></blockquote>
    1542. 

  1542. 

  1543. <h4><a name="conditions" class=none>Conditions</a></h4>
    1544. 

  1544. 

  1545. <p><br>[Condition type]
    1546. 

  1546. <br><a class=none name="ppcre-error"><b>ppcre-error</b></a>
    1547. 

  1547. 

  1548. <blockquote><br>
    1549. 

  1549. Every error signaled by CL-PPCRE is of type
    1550. 

  1550. <code>PPCRE-ERROR</code>. This is a direct subtype of <a
    1551. 

  1551. href="http://www.lispworks.com/documentation/HyperSpec/Body/e_smp_er.htm"><code>SIMPLE-ERROR</code></a>
    1552. 

  1552. without any additional slots or options.
    1553. 

  1553. </blockquote>
    1554. 

  1554. 

  1555. <p><br>[Condition type]
    1556. 

  1556. <br><a class=none name="ppcre-invocation-error"><b>ppcre-invocation-error</b></a>
    1557. 

  1557. 

  1558. <blockquote><br>
    1559. 

  1559. Errors of type <code>PPCRE-INVOCATION-ERROR</code>
    1560. 

  1560. are signaled if one of the exported functions of CL-PPCRE is called with wrong or
    1561. 

  1561. inconsistent arguments. This is a direct subtype of <a
    1562. 

  1562. href="#ppcre-error"><code>PPCRE-ERROR</code></a> without any
    1563. 

  1563. additional slots or options.
    1564. 

  1564. </blockquote>
    1565. 

  1565. 

  1566. <p><br>[Condition type]
    1567. 

  1567. <br><a class=none name="ppcre-syntax-error"><b>ppcre-syntax-error</b></a>
    1568. 

  1568. 

  1569. <blockquote><br>
    1570. 

  1570. An error of type <code>PPCRE-SYNTAX-ERROR</code> is signaled if
    1571. 

  1571. CL-PPCRE's parser encounters an error when trying to parse a regex
    1572. 

  1572. string or to convert a parse tree into its internal representation.
    1573. 

  1573. This is a direct subtype of <a
    1574. 

  1574. href="#ppcre-error"><code>PPCRE-ERROR</code></a> with two additional
    1575. 

  1575. slots. These denote the regex string which HTML-PPCRE was parsing and
    1576. 

  1576. the position within the string where the error occurred.  If the error
    1577. 

  1577. happens while CL-PPCRE is converting a parse tree, both of these slots
    1578. 

  1578. contain <code>NIL</code>.  (See the next two entries on how to access
    1579. 

  1579. these slots.)
    1580. 

  1580. <p>
    1581. 

  1581. As many syntax errors can't be detected before the parser is at the
    1582. 

  1582. end of the stream, the row and column usually denote the last position
    1583. 

  1583. where the parser was happy and not the position where it gave up.
    1584. 

  1584. 

  1585. <pre>
    1586. 

  1586. * (handler-case
    1587. 

  1587.     (scan &quot;foo**x&quot; &quot;fooox&quot;)
    1588. 

  1588.     (ppcre-syntax-error (condition)
    1589. 

  1589.       (format t &quot;Houston, we've got a problem with the string ~S:~%~
    1590. 

  1590.                  Looks like something went wrong at position ~A.~%~
    1591. 

  1591.                  The last message we received was \&quot;~?\&quot;.&quot;
    1592. 

  1592.               (ppcre-syntax-error-string condition)
    1593. 

  1593.               (ppcre-syntax-error-pos condition)
    1594. 

  1594.               (simple-condition-format-control condition)
    1595. 

  1595.               (simple-condition-format-arguments condition))
    1596. 

  1596.       (values)))
    1597. 

  1597. Houston, we've got a problem with the string &quot;foo**x&quot;:
    1598. 

  1598. Looks like something went wrong at position 4.
    1599. 

  1599. The last message we received was &quot;Quantifier '*' not allowed.&quot;.
    1600. 

  1600. </pre>
    1601. 

  1601. </blockquote>
    1602. 

  1602. 

  1603. <p><br>[Function]
    1604. 

  1604. <br><a class=none name="ppcre-syntax-error-string"><b>ppcre-syntax-error-string</b></a> <i>condition</i> =&gt; <i>string</i>
    1605. 

  1605. 

  1606. <blockquote><br>
    1607. 

  1607. If <code><i>condition</i></code> is a condition of type <a
    1608. 

  1608. href="#ppcre-syntax-error"><code>PPCRE-SYNTAX-ERROR</code></a>, this
    1609. 

  1609. function will return the string the parser was parsing when the error was
    1610. 

  1610. encountered (or <code>NIL</code> if the error happened while trying to
    1611. 

  1611. convert a parse tree). This might be particularly useful when <a
    1612. 

  1612. href="#*allow-quoting*"><code>*ALLOW-QUOTING*</code></a> is
    1613. 

  1613. <em>true</em> because in this case the offending string might not be the one you gave to the <a
    1614. 

  1614. href="#create-scanner"><code>CREATE-SCANNER</code></a> function.
    1615. 

  1615. </blockquote>
    1616. 

  1616. 

  1617. <p><br>[Function]
    1618. 

  1618. <br><a class=none name="ppcre-syntax-error-pos"><b>ppcre-syntax-error-pos</b></a> <i>condition</i> =&gt; <i>number</i>
    1619. 

  1619. 

  1620. <blockquote><br>
    1621. 

  1621. If <code><i>condition</i></code> is a condition of type <a
    1622. 

  1622. href="#ppcre-syntax-error"><code>PPCRE-SYNTAX-ERROR</code></a>, this
    1623. 

  1623. function will return the position within the string where the error
    1624. 

  1624. occurred (or <code>NIL</code> if the error happened while trying to
    1625. 

  1625. convert a parse tree).
    1626. 

  1626. </blockquote>
    1627. 

  1627. 

  1628. <br>&nbsp;<br><h3><a name="unicode" class=none>Unicode properties</a></h3>
    1629. 

  1629. 

  1630. You can add support for Unicode properties to CL-PPCRE by loading
    1631. 

  1631. the CL-PPCRE-UNICODE system (which depends on <a href="http://weitz.de/cl-unicode/">CL-UNICODE</a>):
    1632. 

  1632. <pre>
    1633. 

  1633. (asdf:oos 'asdf:load-op :cl-ppcre-unicode)
    1634. 

  1634. </pre>
    1635. 

  1635. This will automatically
    1636. 

  1636. install <a href="#unicode-property-resolver"><code>UNICODE-PROPERTY-RESOLVER</code></a>
    1637. 

  1637. as your <a href="#*property-resolver*">property resolver</a>.
    1638. 

  1638. <p>
    1639. 

  1639. See the <a href="http://weitz.de/cl-unicode/">CL-UNICODE</a>
    1640. 

  1640. documentation for information about the supported Unicode properties
    1641. 

  1641. and how they are named.
    1642. 

  1642. 

  1643. <p><br>[Function]<br><a class=none name='unicode-property-resolver'><b>unicode-property-resolver</b> <i>property-name</i> =&gt; <i>function-or-nil</i></a>
    1644. 

  1644. <blockquote><br>
    1645. 

  1645. A <a href="#*property-resolver*">property
    1646. 

  1646. resolver</a> which understands Unicode properties using
    1647. 

  1647. <a href="http://weitz.de/cl-unicode/">CL-UNICODE</a>'s <a href="http://weitz.de/cl-unicode/#property-test"><code>PROPERTY-TEST</code></a>
    1648. 

  1648. function.  This resolver is automatically installed
    1649. 

  1649. in <a href="#*property-resolver*"><code>*PROPERTY-RESOLVER*</code></a>
    1650. 

  1650. when the <a href="#unicode">CL-PPCRE-UNICODE</a> system is loaded.
    1651. 

  1651. <pre>
    1652. 

  1652. * (scan-to-strings "\\p{Script:Latin}+" "0+AB_*")
    1653. 

  1653. "AB"
    1654. 

  1654. #()
    1655. 

  1655. </pre>
    1656. 

  1656. Note that this symbol is exported from
    1657. 

  1657. the <code>CL-PPCRE-UNICODE</code> package and not from
    1658. 

  1658. the <code>CL-PPCRE</code> package.
    1659. 

  1659. </blockquote>
    1660. 

  1660. 

  1661. 

  1662. <br>&nbsp;<br><h3><a name="filters" class=none>Filters</a></h3>
    1663. 

  1663. 

  1664. Because several users have asked for it, CL-PPCRE now offers
    1665. 

  1665. &quot;filters&quot; (see <a href="#filterdef">above</a> for syntax)
    1666. 

  1666. which are basically arbitrary, user-defined functions that can act as
    1667. 

  1667. regex building blocks. Filters can only be used within <a
    1668. 

  1668. href="#create-scanner2">parse trees</a>, not within Perl regex
    1669. 

  1669. strings.
    1670. 

  1670. <p>
    1671. 

  1671. A filter is defined by its <em>filter function</em> which must be a
    1672. 

  1672. function of one argument. During the parsing process this function
    1673. 

  1673. might be called once or several times or it might not be called at
    1674. 

  1674. all. If it's called, its argument is an integer <code><i>pos</i></code>
    1675. 

  1675. which is the current position within the target string. The filter can
    1676. 

  1676. either return <code>NIL</code> (which means that the subexpression
    1677. 

  1677. represented by this filter didn't match) or an integer not smaller
    1678. 

  1678. than <code><i>pos</i></code> for success. A zero-length assertion
    1679. 

  1679. should return <code><i>pos</i></code> itself while a filter which
    1680. 

  1680. wants to consume <code>N</code> characters should return
    1681. 

  1681. <code>(+&nbsp;POS&nbsp;N)</code>.
    1682. 

  1682. <p>
    1683. 

  1683. If you supply the optional value <code><i>length</i></code> and it is
    1684. 

  1684. not <code>NIL</code>, then this is a promise to the regex engine that
    1685. 

  1685. your filter will <em>always</em> consume <em>exactly</em>
    1686. 

  1686. <code><i>length</i></code> characters. The regex engine might use this
    1687. 

  1687. information for optimization purposes but it is otherwise irrelevant
    1688. 

  1688. to the outcome of the matching process.
    1689. 

  1689. <p>
    1690. 

  1690. The filter function can access the following special variables from
    1691. 

  1691. its code body:
    1692. 

  1692. <dl>
    1693. 

  1693. 

  1694. <dt><code>CL-PPCRE::*STRING*</code></dt>
    1695. 

  1695. <dd>The target (a string) of the current matching process.</dd>
    1696. 

  1696. 

  1697. <dt><code>CL-PPCRE::*START-POS*</code> and
    1698. 

  1698. <code>CL-PPCRE::*END-POS*</code></dt>
    1699. 

  1699. <dd>The start and end (integers) indices
    1700. 

  1700. of the current matching process. These correspond to the
    1701. 

  1701. <code>START</code> and <code>END</code> keyword parameters
    1702. 

  1702. of <a href="#scan"><code>SCAN</code></a>.</dd>
    1703. 

  1703. 

  1704. <dt><code>CL-PPCRE::*REAL-START-POS*</code></dt>
    1705. 

  1705. <dd>The initial starting
    1706. 

  1706. position. This is only relevant for repeated scans (as in <a
    1707. 

  1707. href="#do-scans"><code>DO-SCANS</code></a>) where
    1708. 

  1708. <code>CL-PPCRE::*START-POS*</code> will be moved forward while
    1709. 

  1709. <code>CL-PPCRE::*REAL-START-POS*</code> won't. For normal scans the
    1710. 

  1710. value of this variable is <code>NIL</code>.</dd>
    1711. 

  1711. 

  1712. <dt><CODE>CL-PPCRE::*REG-STARTS*</CODE> and
    1713. 

  1713. <CODE>CL-PPCRE::*REG-ENDS*</CODE></dt>
    1714. 

  1714. <dd>Two simple vectors which denote the
    1715. 

  1715. start and end indices of registers within the regular expression. The
    1716. 

  1716. first register is indexed by&nbsp;0. If a register hasn't matched yet,
    1717. 

  1717. then its corresponding entry in <CODE>CL-PPCRE::*REG-STARTS*</CODE> is
    1718. 

  1718. <code>NIL</code>.</dd>
    1719. 

  1719. 

  1720. </dl>
    1721. 

  1721. 

  1722. These variables should be considered read-only. Do <em>not</em> change
    1723. 

  1723. these values unless you really know what you're doing!
    1724. 

  1724. <p>
    1725. 

  1725. Note that the names of the variables are not exported from the
    1726. 

  1726. <code>CL-PPCRE</code> package because there's no explicit guarantee
    1727. 

  1727. that they will be available in future releases.  (Although after so
    1728. 

  1728. many years it is <em>very</em> unlikely that they'll go away...)
    1729. 

  1729. <pre>
    1730. 

  1730. * (defun my-info-filter (pos)
    1731. 

  1731.     &quot;Show some info about the matching process.&quot;
    1732. 

  1732.     (format t &quot;Called at position ~A~%&quot; pos)
    1733. 

  1733.     (loop with dim = (array-dimension cl-ppcre::*reg-starts* 0)
    1734. 

  1734.           for i below dim
    1735. 

  1735.           for reg-start = (aref cl-ppcre::*reg-starts* i)
    1736. 

  1736.           for reg-end = (aref cl-ppcre::*reg-ends* i)
    1737. 

  1737.           do (format t &quot;Register ~A is currently &quot; (1+ i))
    1738. 

  1738.           when reg-start
    1739. 

  1739.                (write-string cl-ppcre::*string* nil
    1740. 

  1740.             do (write-char #\')
    1741. 

  1741.                (write-string cl-ppcre::*string* nil
    1742. 

  1742.                      :start reg-start :end reg-end)
    1743. 

  1743.                (write-char #\')
    1744. 

  1744.           else
    1745. 

  1745.             do (write-string &quot;unbound&quot;)
    1746. 

  1746.           do (terpri))
    1747. 

  1747.     (terpri)
    1748. 

  1748.     pos)
    1749. 

  1749. MY-INFO-FILTER
    1750. 

  1750. 

  1751. * (scan '(:sequence
    1752. 

  1752.            (:register
    1753. 

  1753.              (:greedy-repetition 0 nil
    1754. 

  1754.                                  (:char-class (:range #\a #\z))))
    1755. 

  1755.            (:filter my-info-filter 0) &quot;X&quot;)
    1756. 

  1756.         &quot;bYcdeX&quot;)
    1757. 

  1757. Called at position 1
    1758. 

  1758. Register 1 is currently 'b'
    1759. 

  1759. 

  1760. Called at position 0
    1761. 

  1761. Register 1 is currently ''
    1762. 

  1762. 

  1763. Called at position 1
    1764. 

  1764. Register 1 is currently ''
    1765. 

  1765. 

  1766. Called at position 5
    1767. 

  1767. Register 1 is currently 'cde'
    1768. 

  1768. 

  1769. 2
    1770. 

  1770. 6
    1771. 

  1771. #(2)
    1772. 

  1772. #(5)
    1773. 

  1773. 

  1774. * (scan '(:sequence
    1775. 

  1775.            (:register
    1776. 

  1776.              (:greedy-repetition 0 nil
    1777. 

  1777.                                  (:char-class (:range #\a #\z))))
    1778. 

  1778.            (:filter my-info-filter 0) &quot;X&quot;)
    1779. 

  1779.         &quot;bYcdeZ&quot;)
    1780. 

  1780. NIL
    1781. 

  1781. 

  1782. * (defun my-weird-filter (pos)
    1783. 

  1783.     &quot;Only match at this point if either pos is odd and the character
    1784. 

  1784.   we're looking at is lowercase or if pos is even and the next two
    1785. 

  1785.   characters we're looking at are uppercase. Consume these characters if
    1786. 

  1786.   there's a match.&quot;
    1787. 

  1787.     (format t &quot;Trying at position ~A~%&quot; pos)
    1788. 

  1788.     (cond ((and (oddp pos)
    1789. 

  1789.                 (&lt; pos cl-ppcre::*end-pos*)
    1790. 

  1790.                 (lower-case-p (char cl-ppcre::*string* pos)))
    1791. 

  1791.            (1+ pos))
    1792. 

  1792.           ((and (evenp pos)
    1793. 

  1793.                 (&lt; (1+ pos) cl-ppcre::*end-pos*)
    1794. 

  1794.                 (upper-case-p (char cl-ppcre::*string* pos))
    1795. 

  1795.                 (upper-case-p (char cl-ppcre::*string* (1+ pos))))
    1796. 

  1796.            (+ pos 2))
    1797. 

  1797.           (t nil)))
    1798. 

  1798. MY-WEIRD-FILTER
    1799. 

  1799. 

  1800. * (defparameter *weird-regex*
    1801. 

  1801.                 `(:sequence &quot;+&quot; (:filter ,#'my-weird-filter) &quot;+&quot;))
    1802. 

  1802. *WEIRD-REGEX*
    1803. 

    1804. 

  1804. * (scan *weird-regex* &quot;+A++a+AA+&quot;)
    1805. 

  1805. Trying at position 1
    1806. 

  1806. Trying at position 3
    1807. 

  1807. Trying at position 4
    1808. 

  1808. Trying at position 6
    1809. 

  1809. 5
    1810. 

  1810. 9
    1811. 

  1811. #()
    1812. 

  1812. #()
    1813. 

    1814. 

  1814. * (fmakunbound 'my-weird-filter)
    1815. 

  1815. MY-WEIRD-FILTER
    1816. 

    1817. 

  1817. * (scan *weird-regex* &quot;+A++a+AA+&quot;)
    1818. 

  1818. Trying at position 1
    1819. 

  1819. Trying at position 3
    1820. 

  1820. Trying at position 4
    1821. 

  1821. Trying at position 6
    1822. 

  1822. 5
    1823. 

  1823. 9
    1824. 

  1824. #()
    1825. 

  1825. #()
    1826. 

  1826. </pre>
    1827. 

    1828. 

  1828. Note that in the second call to <code>SCAN</code> our filter wasn't
    1829. 

  1829. invoked at all - it was optimized away by the regex engine because it
    1830. 

  1830. knew that it couldn't match. Also note that <code>*WEIRD-REGEX*</code>
    1831. 

  1831. still worked after we removed the global function definition of
    1832. 

  1832. <code>MY-WEIRD-FILTER</code> because the regular expression had
    1833. 

  1833. captured the original definition.
    1834. 

    1835. 

  1835. <p>
    1836. 

    1837. 

  1837. For more ideas about what you can do with filters see <a
    1838. 

  1838. href="http://common-lisp.net/pipermail/cl-ppcre-devel/2004-October/000069.html">this
    1839. 

  1839. thread</a> on the <a href="#mail">mailing list</a>.
    1840. 

    1841. 

  1841. <br>&nbsp;<br><h3><a name="perl" class=none>Compatibility with Perl</a></h3>
    1842. 

    1843. 

  1843. Depending on your Perl version you might encounter a couple of small
    1844. 

  1844. incompatibilities with Perl most of which aren't due to CL-PPCRE:
    1845. 

    1846. 

  1846. <h4><a name="empty" class=none>Empty strings instead of <code>undef</code> in <code>$1</code>, <code>$2</code>, etc.</a></h4>
    1847. 

    1848. 

  1848. (Cf. case #629 of <a href="#test"><code>perltestdata</code></a>.)
    1849. 

  1849. This is <a
    1850. 

  1850. href="http://groups.google.com/groups?threadm=87u1kw8hfr.fsf%40dyn164.dbdmedia.de">a
    1851. 

  1851. bug</a> in Perl 5.6.1 and earlier which has been fixed in 5.8.0.
    1852. 

    1853. 

  1853. <h4><a name="scope" class=none>Strange scoping of embedded modifiers</a></h4>
    1854. 

    1855. 

  1855. (Cf. case #430 of <a href="#test"><code>perltestdata</code></a>.)
    1856. 

  1856. This is <a
    1857. 

  1857. href="http://groups.google.com/groups?threadm=871y80dpqh.fsf%40bird.agharta.de">a
    1858. 

  1858. bug</a> in Perl 5.6.1 and earlier which has been fixed in 5.8.0.
    1859. 

    1860. 

  1860. <h4><a name="inconsistent" class=none>Inconsistent capturing of <code>$1</code>, <code>$2</code>, etc.</a></h4>
    1861. 

    1862. 

  1862. (Cf. case #662 of <a href="#test"><code>perltestdata</code></a>.)
    1863. 

  1863. This is <a
    1864. 

  1864. href="http://bugs6.perl.org/rt2/Ticket/Display.html?id=18708">a
    1865. 

  1865. bug</a> in Perl which hasn't been fixed yet.
    1866. 

    1867. 

  1867. <h4><a name="lookaround" class=none>Captured groups not available outside of look-aheads and look-behinds</a></h4>
    1868. 

    1869. 

  1869. (Cf. case #1439 of <a href="#test"><code>perltestdata</code></a>.)
    1870. 

  1870. Well, OK, this ain't a Perl bug. I just can't quite understand why
    1871. 

  1871. captured groups should only be seen within the scope of a look-ahead
    1872. 

  1872. or look-behind. For the moment, CL-PPCRE and Perl agree to
    1873. 

  1873. disagree... :)
    1874. 

    1875. 

  1875. <h4><a name="order" class=none>Alternations don't always work from left to right</a></h4>
    1876. 

    1877. 

  1877. (Cf. case #790 of <a href="#test"><code>perltestdata</code></a>.) I
    1878. 

  1878. also think this a Perl bug but I currently have lost the drive to
    1879. 

  1879. report it.
    1880. 

    1881. 

  1881. <h4><a name="uprops" class=none>Different names for Unicode properties</a></h4>
    1882. 

    1883. 

  1883. The names of <a href="#unicode">Unicode properties</a> are derived
    1884. 

  1884. from <a href="http://weitz.de/cl-unicode/">CL-UNICODE</a> and might
    1885. 

  1885. differ slightly from the names in Perl.  Most of them should be
    1886. 

  1886. identical, though.
    1887. 

  1887. Also, <a href="http://weitz.de/cl-unicode/">CL-UNICODE</a> is based on
    1888. 

  1888. Unicode&nbsp;5.1 while your installed Perl version might be not.
    1889. 

    1890. 

  1890. <h4><a name="mac" class=none><code>&quot;\r&quot;</code> doesn't work with MCL</a></h4>
    1891. 

    1892. 

  1892. (Cf. case #9 of <a href="#test"><code>perltestdata</code></a>.) For
    1893. 

  1893. some strange reason that I don't understand MCL translates
    1894. 

  1894. <code>#\Return</code> to <code>(CODE-CHAR 10)</code> while MacPerl
    1895. 

  1895. translates <code>&quot;\r&quot;</code> to <code>(CODE-CHAR
    1896. 

  1896. 13)</code>. Hmmm...
    1897. 

    1898. 

  1898. <h4><a name="alpha" class=none>What about <code>&quot;\w&quot;</code>?</a></h4>
    1899. 

    1900. 

  1900. CL-PPCRE uses <a
    1901. 

  1901. href="http://www.lispworks.com/documentation/HyperSpec/Body/f_alphan.htm"><code>ALPHANUMERICP</code></a>
    1902. 

  1902. to decide whether a character matches Perl's
    1903. 

  1903. <code>&quot;\w&quot;</code>, so depending on your CL implementation
    1904. 

  1904. you might encounter differences between Perl and CL-PPCRE when
    1905. 

  1905. matching non-ASCII characters.
    1906. 

    1907. 

  1907. <br>&nbsp;<br><h3><a name="bugs" class=none>Bugs and problems</a></h3>
    1908. 

    1909. 

  1909. <h4><a name="quote" class=none><code>&quot;\Q&quot;</code> doesn't work, or does it?</a></h4>
    1910. 

    1911. 

  1911. In Perl the following code works as expected, i.e. it prints <code>1</code>.
    1912. 

  1912. <pre>
    1913. 

  1913. #!/usr/bin/perl -l
    1914. 

    1915. 

  1915. $a = '\E*';
    1916. 

  1916. print 1
    1917. 

  1917.   if '\E*\E*' =~ /(?:\Q$a\E){2}/;
    1918. 

  1918. </pre>
    1919. 

    1920. 

  1920. If you try to do something similar in CL-PPCRE, you get an error:
    1921. 

    1922. 

  1922. <pre>
    1923. 

  1923. * (let ((*allow-quoting* t)
    1924. 

  1924.         (a &quot;\\E*&quot;))
    1925. 

  1925.     (scan (concatenate 'string &quot;(?:\\Q&quot; a &quot;\\E){2}&quot;) &quot;\\E*\\E*&quot;))
    1926. 

  1926. Quantifier '*' not allowed at position 3 in string &quot;(?:*\\E){2}&quot;
    1927. 

  1927. </pre>
    1928. 

    1929. 

  1929. The error message might give you a hint as to why this happens:
    1930. 

  1930. Because <a href="#*allow-quoting*"><code>*ALLOW-QUOTING*</code></a>
    1931. 

  1931. was <em>true</em> the concatenated string was pre-processed before it
    1932. 

  1932. was fed to CL-PPCRE's parser - the result of this pre-processing is
    1933. 

  1933. <code>&quot;(?:*\\E){2}&quot;</code> because the
    1934. 

  1934. <code>&quot;\\E&quot;</code> in the string <code>A</code> was taken to
    1935. 

  1935. be the end of the quoted section started by
    1936. 

  1936. <code>&quot;\\Q&quot;</code>. This cannot happen in Perl due to its
    1937. 

  1937. complicated interpolation rules - see <code>man&nbsp;perlop</code> for
    1938. 

  1938. the scary details. It <em>can</em> happen in CL-PPCRE, though.
    1939. 

  1939. Bummer!
    1940. 

  1940. <p>
    1941. 

  1941. What gives? <code>&quot;\\Q...\\E&quot;</code> in CL-PPCRE should only
    1942. 

  1942. be used in literal strings. If you want to quote arbitrary strings,
    1943. 

  1943. try <a href="http://weitz.de/cl-interpol/">CL-INTERPOL</a> or use <a
    1944. 

  1944. href="#quote-meta-chars"><code>QUOTE-META-CHARS</code></a>:
    1945. 

  1945. <pre>
    1946. 

  1946. * (let ((a &quot;\\E*&quot;))
    1947. 

  1947.     (scan (concatenate 'string &quot;(?:&quot; (quote-meta-chars a) &quot;){2}&quot;) &quot;\\E*\\E*&quot;))
    1948. 

  1948. 0
    1949. 

  1949. 6
    1950. 

  1950. #()
    1951. 

  1951. #()
    1952. 

  1952. </pre>
    1953. 

  1953. Or, even better and Lisp-ier, use the <a href="#create-scanner2">S-expression syntax</a> instead - no need for quoting in this case:
    1954. 

  1954. <pre>
    1955. 

  1955. * (let ((a "\\E*"))
    1956. 

  1956.     (scan `(:greedy-repetition 2 2 ,a) "\\E*\\E*"))
    1957. 

  1957. 0
    1958. 

  1958. 6
    1959. 

  1959. #()
    1960. 

  1960. #()
    1961. 

  1961. </pre>
    1962. 

  1962. 

  1963. <h4><a name="backslash" class=none>Backslashes may confuse you...</a></h4>
    1964. 

  1964. 

  1965. <pre>
    1966. 

  1966. * (let ((a &quot;y\\y&quot;))
    1967. 

  1967.     (scan a a))
    1968. 

  1968. NIL
    1969. 

  1969. </pre>
    1970. 

  1970. 

  1971. You didn't expect this to yield <code>NIL</code>, did you? Shouldn't something like <code>(SCAN&nbsp;A&nbsp;A)</code> always return a true value? No, because the first and the second argument to <code>SCAN</code> are handled differently: The first argument is fed to CL-PPCRE's parser and is treated like a Perl regular expression. In particular, the parser "sees" <code>\y</code> and converts it to <code>y</code> because <code>\y</code> has no special meaning in regular expressions. So, the regular expression is the constant string <code>"yy"</code>. But the second argument isn't converted - it is left as is, i.e. it's equivalent to Perl's <code>'y\y'</code>. In other words, this example would be equivalent to the Perl code
    1972. 

  1972. 

  1973. <pre>
    1974. 

  1974. 'y\y' =~ /y\y/;
    1975. 

  1975. </pre>
    1976. 

  1976. 

  1977. or to
    1978. 

  1978. 

  1979. <pre>
    1980. 

  1980. $a = 'y\y';
    1981. 

  1981. $a =~ /$a/;
    1982. 

  1982. </pre>
    1983. 

  1983. 

  1984. which should explain why it doesn't match.
    1985. 

  1985. <p>
    1986. 

  1986. Still confused? You might want to try <a href="http://weitz.de/cl-interpol/">CL-INTERPOL</a>.
    1987. 

  1987. 

  1988. <br>&nbsp;<br><h3><a class=none name="allegro">AllegroCL compatibility mode</a></h3>
    1989. 

  1989. 

  1990. Since autumn 2004 <a
    1991. 

  1991. href="http://www.franz.com/products/allegrocl/">AllegroCL</a> offers
    1992. 

  1992. <a
    1993. 

  1993. href="http://www.franz.com/support/documentation/7.0/doc/regexp.htm">a
    1994. 

  1994. new regular expression API</a> with a syntax very similar to
    1995. 

  1995. CL-PPCRE. Although CL-PPCRE is quite fast already, AllegroCL's engine will
    1996. 

  1996. most likely be even faster (but only on AllegroCL, of course).  However, you might want to
    1997. 

  1997. stick to CL-PPCRE because you have a "legacy" application or because
    1998. 

  1998. you want your code to be portable to other Lisp implementations.
    1999. 

  1999. Therefore, beginning from version 1.2.0, CL-PPCRE offers a
    2000. 

  2000. "compatibility mode" where you can continue using the CL-PPCRE API as
    2001. 

  2001. described <a href="#dict">above</a> but deploy the AllegroCL regex
    2002. 

  2002. engine under the hood. (The details are: Calls to <a
    2003. 

  2003. href="#create-scanner"><code>CREATE-SCANNER</code></a> and <a
    2004. 

  2004. href="#scan"><code>SCAN</code></a> are dispatched to their AllegroCL
    2005. 

  2005. counterparts <a
    2006. 

  2006. href="http://www.franz.com/support/documentation/7.0/doc/operators/excl/compile-re.htm"><code>EXCL:COMPILE-RE</code></a>
    2007. 

  2007. and <a
    2008. 

  2008. href="http://www.franz.com/support/documentation/7.0/doc/operators/excl/match-re.htm"><code>EXCL:MATCH-RE</code></a>
    2009. 

  2009. while everything else is left as is.)
    2010. 

  2010. <p>
    2011. 

  2011. The advantage of this mode is that you'll get a much smaller image and
    2012. 

  2012. most likely faster code. (But note that CL-PPCRE needs to do a small amount of work to massage AllegroCL's output into the format expected by CL-PPCRE.) The downside is that your code won't be
    2013. 

  2013. fully compatible with CL-PPCRE anymore. Here are some of the
    2014. 

  2014. differences (most of which probably don't matter very often):
    2015. 

  2015. <ul>
    2016. 

  2016. <li>The AllegroCL engine doesn't offer <a
    2017. 

  2017. href="#parse-tree-synonym">parse tree synonyms</a> and <a href="#filters">filters</a>.
    2018. 

  2018. <li>The AllegroCL engine <a href="http://www.franz.com/support/documentation/8.0/doc/regexp.htm#regexp-new-compatibility-2">will choke on some regular expressions involving curly braces</a> that are accepted by Perl and CL-PPCRE's native engine.
    2019. 

  2019. <li>The AllegroCL engine's case-folding mode switch (which is used instead of CL-PPCRE's <a href="#create-scanner"><code>:CASE-INSENSITIVE</code> keyword parameter</a>) <a href="http://www.franz.com/support/documentation/8.0/doc/regexp.htm#regexp-new-matching-2">is currently only effective for ASCII characters</a>.
    2020. 

  2020. <li>The AllegroCL engine <a href="http://www.franz.com/support/documentation/8.0/doc/regexp.htm#regexp-new-compatibility-2">doesn't support</a> <a href="#*allow-quoting*">quoting of metacharacters</a>.
    2021. 

  2021. <li>In AllegroCL compatibility mode compiled regular expressions (as returned by <a href="#create-scanner"><code>CREATE-SCANNER</code></a>) aren't functions but structures.
    2022. 

  2022. <li>The AllegroCL engine <a href="http://www.franz.com/support/documentation/8.0/doc/regexp.htm#regexp-new-compatibility-2">doesn't support</a> <a href="#*property-resolver*">named properties</a>.
    2023. 

  2023. </ul>
    2024. 

  2024. For more details about the AllegroCL engine and possible deviations from CL-PPCRE see the <a href="http://www.franz.com/support/documentation/8.0/doc/regexp.htm">documentation</a> at the <a href="http://www.franz.com/">Franz Inc. website</a>.
    2025. 

  2025. <p>
    2026. 

  2026. To use the AllegroCL compatibility mode you have to
    2027. 

  2027. <pre>
    2028. 

  2028. (push :use-acl-regexp2-engine *features*)
    2029. 

  2029. </pre>
    2030. 

  2030. <em>before</em> you compile CL-PPCRE.
    2031. 

  2031. 

  2032. <br>&nbsp;<br><h3><a class=none name="blabla">Hints, comments, performance considerations</a></h3>
    2033. 

  2033. 

  2034. Here are, in no particular order, a couple of things about CL-PPCRE 
    2035. 

  2035. and regular expressions in general that you might or might not want to
    2036. 

  2036. read.
    2037. 

  2037. 

  2038. <ul>
    2039. 

  2039.   <li>A lot of hackers (especially users of Perl and other scripting
    2040. 

  2040.   languages) think that regular expressions are the greatest thing
    2041. 

  2041.   since sliced bread and use it for almost everything.  That is just
    2042. 

  2042.   plain wrong.  Other hackers (especially Lispers) tend to think that
    2043. 

  2043.   regular expressions are the work of the devil and try to avoid them
    2044. 

  2044.   at all cost.  That's also wrong.  Regular expressions are a handy
    2045. 

  2045.   and useful addition to your toolkit which you should use when
    2046. 

  2046.   appropriate - you should just try to figure out first <em>if</em>
    2047. 

  2047.   they're appropriate for the task at hand.
    2048. 

    2049. 

  2049.   <li>If you're concerned about the string syntax of regular
    2050. 

  2050.   expressions which can look like line noise and is really hard to
    2051. 

  2051.   read for long expressions, consider using
    2052. 

  2052.   CL-PPCRE's <a href="#create-scanner2">S-expression syntax</a>
    2053. 

  2053.   instead.  It is less error-prone and you don't have to worry about
    2054. 

  2054.   escaping characters.  It is also easier to manipulate
    2055. 

  2055.   programmatically.
    2056. 

  2056. 

  2057.   <li>For alternations, order is important.  The general rule is that
    2058. 

  2058.   the regex engine tries from left to right and tries to match as much
    2059. 

  2059.   as possible.
    2060. 

  2060. <pre>
    2061. 

  2061. CL-USER 1 > (scan-to-strings "<=|<" "<=")
    2062. 

  2062. "<="
    2063. 

  2063. #()
    2064. 

  2064. 

  2065. CL-USER 2 > (scan-to-strings "<|<=" "<=")
    2066. 

  2066. "<"
    2067. 

  2067. #()
    2068. 

  2068. </pre>
    2069. 

  2069. 

  2070.    <li><a class=none name="compiler-macro">CL-PPCRE</a>
    2071. 

  2071.    uses <a href="http://www.lispworks.com/documentation/HyperSpec/Body/03_bba.htm">compiler
    2072. 

  2072.    macros</a> to pre-compile scanners
    2073. 

  2073.    at <a href=="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_l.htm#load_time">load
    2074. 

  2074.    time</a> if possible.  This happens if the compiler can determine
    2075. 

  2075.    that the regular expression (no matter if it's a string or an
    2076. 

  2076.    S-expression)
    2077. 

  2077.    is <a href="http://www.lispworks.com/documentation/HyperSpec/Body/f_consta.htm">constant</a>
    2078. 

  2078.    at <a href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_c.htm#compile_time">compile
    2079. 

  2079.    time</a> and is intended to save the time for creating scanners
    2080. 

  2080.    at <a href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_e.htm#execution_time">execution
    2081. 

  2081.    time</a> (probably creating the same scanner over and over in a
    2082. 

  2082.    loop).  Make sure you don't prevent the compiler from helping you.
    2083. 

  2083.    For example, a definition like this one is usually not a good idea:
    2084. 

  2084. <pre>
    2085. 

  2085. (defun regex-match (regex target)
    2086. 

  2086.   <font color=orange>;; don't do that!</font>
    2087. 

  2087.   (scan regex target))
    2088. 

  2088. </pre>
    2089. 

  2089. 

  2090.   <li>If you want to search for a substring in a large string or if
    2091. 

  2091.   you search for the same string very
    2092. 

  2092.   often, <a href="#scan"><code>SCAN</code></a> will usually be faster
    2093. 

  2093.   than Common
    2094. 

  2094.   Lisp's <a href="http://www.lispworks.com/documentation/HyperSpec/Body/f_search.htm"><code>SEARCH</code></a>
    2095. 

  2095.   if you <a href="#*use-bmh-matchers*">use BMH matchers</a>.  However,
    2096. 

  2096.   this only makes sense if scanner creation time is not the
    2097. 

  2097.   limiting factor, i.e. if the search target is <em>very</em> large or
    2098. 

  2098.   if you're using the same scanner very often.
    2099. 

    2100. 

  2100.   <li>Complementary to the last hint, <em>don't</em> use regular
    2101. 

  2101.   expressions for one-time searches for constant strings.  That's a
    2102. 

  2102.   terrible waste of resources.
    2103. 

  2103. 

  2104.   <li><a href="#*use-bmh-matchers*"><code>*USE-BMH-MATCHERS*</code></a> together with a large value for
    2105. 

  2105.   <a href="#*regex-char-code-limit*"><code>*REGEX-CHAR-CODE-LIMIT*</code></a>
    2106. 

  2106.   can lead to huge scanners.
    2107. 

  2107. 

  2108.   <li>A character class is by default translated into a sequence of
    2109. 

  2109.   tests exactly as you might expect.  For
    2110. 

  2110.   example, <code>"[af-l\\d]"</code> means to test if the character is
    2111. 

  2111.   equal to <code>#\a</code>, then to test if it's
    2112. 

  2112.   between <code>#\f</code> and <code>#\l</code>, then if it's a digit.
    2113. 

  2113.   There's by default no attempt to remove redundancy (as
    2114. 

  2114.   in <code>"[a-ge-kf]"</code>) or to otherwise optimize these tests
    2115. 

  2115.   for speed.  However, you can play
    2116. 

  2116.   with <a href="#*optimize-char-classes*"><code>*OPTIMIZE-CHAR-CLASSES*</code></a>
    2117. 

  2117.   if you've identified character classes as a bottleneck and want to
    2118. 

  2118.   make sure that you have <em>O(1)</em> test functions.
    2119. 

  2119. 

  2120.   <li>If you know that the expression you're looking for is anchored,
    2121. 

  2121.   use anchors in your regex.  This can help the engine a lot to make
    2122. 

  2122.   your scanners more efficient.
    2123. 

  2123. 

  2124.   <li>In addition to anchors, constant strings at the start or end of a
    2125. 

  2125.   regular expression can help the engine to quickly scan a string.
    2126. 

  2126.   Note that for example <code>"(a-d|aebf)"</code>
    2127. 

  2127.   and <code>"ab(cd|ef)"</code> are equivalent, but only the second
    2128. 

  2128.   form has a constant start the regex engine can recognize.
    2129. 

  2129. 

  2130.   <li>Try to avoid alternations if possible or at least factor them
    2131. 

  2131.   out as in the example above.
    2132. 

  2132. 

  2133.   <li>If neither anchors nor constant strings are in sight, maybe
    2134. 

  2134.   "standalone" (sometimes also called "possessive") regular
    2135. 

  2135.   expressions can be helpful.  Try the following:
    2136. 

  2136. <pre>
    2137. 

  2137. (let ((target (make-string 10000 :initial-element #\a))
    2138. 

  2138.       (scanner-1 (create-scanner "a*\\d"))
    2139. 

  2139.       (scanner-2 (create-scanner "(?>a*)\\d")))
    2140. 

  2140.   (time (scan scanner-1 target))
    2141. 

  2141.   (time (scan scanner-2 target)))
    2142. 

  2142. </pre>
    2143. 

  2143. 

  2144.   <li>Consider using <a href="#create-scanner">"single-line mode"</a>
    2145. 

  2145.   if it makes sense for your task.  By default (following Perl's
    2146. 

  2146.   practice), a dot means to search for any character <em>except</em>
    2147. 

  2147.   line breaks.  In single-line mode a dot searches for <em>any</em>
    2148. 

  2148.   character which in some cases means that large parts of the target
    2149. 

  2149.   can actually be skipped.  This can be vastly more efficient for
    2150. 

  2150.   large targets.
    2151. 

  2151. 

  2152.   <li>Don't use capturing register groups where a non-capturing group
    2153. 

  2153.   would do, i.e. <em>only</em> use registers if you need to refer to
    2154. 

  2154.   them later.  If you use a register, each scan process needs to
    2155. 

  2155.   allocate space for it and update its contents (possibly many times)
    2156. 

  2156.   until it's finished.  (In Perl parlance - use <code>"(?:foo)"</code> instead of
    2157. 

  2157.   <code>"(foo)"</code> whenever possible.)
    2158. 

  2158. 

  2159.   <li>In addition to what has been said in the last hint, note that
    2160. 

  2160.   Perl semantics force the regex engine to report the <em>last</em>
    2161. 

  2161.   match for each register.  This implies for example
    2162. 

  2162.   that <code>"([a-c])+"</code> and <code>"[a-c]*([a-c])"</code> have
    2163. 

  2163.   exactly the same semantics but completely different performance
    2164. 

  2164.   characteristics.  (Actually, in some cases CL-PPCRE automatically
    2165. 

  2165.   converts expressions from the first type into the second type.
    2166. 

  2166.   That's not always possible, though, and you shouldn't rely on it.)
    2167. 

  2167. 

  2168.   <li>By default, repetitions are "greedy" in Perl (and thus in
    2169. 

  2169.   CL-PPCRE).  This has an impact on performance and also on the actual
    2170. 

  2170.   outcome of a scan.  Look at your repetitions and ponder if a greedy
    2171. 

  2171.   repetition is really what you want.
    2172. 

  2172. </ul>
    2173. 

  2173. 

  2174. <br>&nbsp;<br><h3><a class=none name="ack">Acknowledgements</a></h3>
    2175. 

  2175. 

  2176. Although I didn't use their code, I was heavily inspired by looking at
    2177. 

  2177. the Scheme/CL regex implementations of <a
    2178. 

  2178. href="http://www.ccs.neu.edu/home/dorai/pregexp/pregexp.html">Dorai
    2179. 

  2179. Sitaram</a> and <a
    2180. 

  2180. href="http://www.geocities.com/mparker762/clawk#regex">Michael
    2181. 

  2181. Parker</a>. Also, the nice folks from CMUCL's <a
    2182. 

  2182. href="http://www.cons.org/cmucl/support.html">mailing list</a> as well
    2183. 

  2183. as the output of Perl's <code>use re &quot;debug&quot;</code> pragma
    2184. 

  2184. have been very helpful in optimizing the scanners created by CL-PPCRE.
    2185. 

  2185. 

  2186. <p>The list of people who participated in this project in one way or
    2187. 

  2187. the other has grown too long to maintain it here.  See
    2188. 

  2188. the <a href="http://weitz.de/cl-ppcre/CHANGELOG">ChangeLog</a> for all
    2189. 

  2189. the people who helped with patches, bug reports, or in other ways.
    2190. 

  2190. Thanks to all of them!
    2191. 

  2191. 

  2192. <p>
    2193. 

  2193. Thanks to the guys at
    2194. 

  2194. &quot;<a href="http://www.weinhandel-ottensen.de/">Caf&eacute;
    2195. 

  2195. Ol&eacute;</a>&quot;
    2196. 

  2196. in <a href="http://en.wikipedia.org/wiki/Hamburg">Hamburg</a> where I
    2197. 

  2197. wrote most of the 0.1.0&nbsp;release and thanks to my wife for lending
    2198. 

  2198. me her PowerBook to test early versions of CL-PPCRE with MCL and
    2199. 

  2199. OpenMCL.
    2200. 

  2200. 

  2201. <p>
    2202. 

  2202. $Header: /usr/local/cvsrep/cl-ppcre/doc/index.html,v 1.200 2009/10/28 07:36:31 edi Exp $
    2203. 

  2203. <p><a href="http://weitz.de/index.html">BACK TO MY HOMEPAGE</a>
    2204. 

  2204. 

  2205. </body>
    2206. 

  2206. </html>
    2207. 

  2207.