/vendor/pcre/README

http://github.com/feyeleanor/RubyGoLightly · #! · 756 lines · 587 code · 169 blank · 0 comment · 0 complexity · 58a510ac9ee2d0e960aa2828aa6900d1 MD5 · raw file

  1. README file for PCRE (Perl-compatible regular expression library)
  2. -----------------------------------------------------------------
  3. The latest release of PCRE is always available in three alternative formats
  4. from:
  5. ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre-xxx.tar.gz
  6. ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre-xxx.tar.bz2
  7. ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre-xxx.zip
  8. There is a mailing list for discussion about the development of PCRE at
  9. pcre-dev@exim.org
  10. Please read the NEWS file if you are upgrading from a previous release.
  11. The contents of this README file are:
  12. The PCRE APIs
  13. Documentation for PCRE
  14. Contributions by users of PCRE
  15. Building PCRE on non-Unix systems
  16. Building PCRE on Unix-like systems
  17. Retrieving configuration information on Unix-like systems
  18. Shared libraries on Unix-like systems
  19. Cross-compiling on Unix-like systems
  20. Using HP's ANSI C++ compiler (aCC)
  21. Making new tarballs
  22. Testing PCRE
  23. Character tables
  24. File manifest
  25. The PCRE APIs
  26. -------------
  27. PCRE is written in C, and it has its own API. The distribution also includes a
  28. set of C++ wrapper functions (see the pcrecpp man page for details), courtesy
  29. of Google Inc.
  30. In addition, there is a set of C wrapper functions that are based on the POSIX
  31. regular expression API (see the pcreposix man page). These end up in the
  32. library called libpcreposix. Note that this just provides a POSIX calling
  33. interface to PCRE; the regular expressions themselves still follow Perl syntax
  34. and semantics. The POSIX API is restricted, and does not give full access to
  35. all of PCRE's facilities.
  36. The header file for the POSIX-style functions is called pcreposix.h. The
  37. official POSIX name is regex.h, but I did not want to risk possible problems
  38. with existing files of that name by distributing it that way. To use PCRE with
  39. an existing program that uses the POSIX API, pcreposix.h will have to be
  40. renamed or pointed at by a link.
  41. If you are using the POSIX interface to PCRE and there is already a POSIX regex
  42. library installed on your system, as well as worrying about the regex.h header
  43. file (as mentioned above), you must also take care when linking programs to
  44. ensure that they link with PCRE's libpcreposix library. Otherwise they may pick
  45. up the POSIX functions of the same name from the other library.
  46. One way of avoiding this confusion is to compile PCRE with the addition of
  47. -Dregcomp=PCREregcomp (and similarly for the other POSIX functions) to the
  48. compiler flags (CFLAGS if you are using "configure" -- see below). This has the
  49. effect of renaming the functions so that the names no longer clash. Of course,
  50. you have to do the same thing for your applications, or write them using the
  51. new names.
  52. Documentation for PCRE
  53. ----------------------
  54. If you install PCRE in the normal way on a Unix-like system, you will end up
  55. with a set of man pages whose names all start with "pcre". The one that is just
  56. called "pcre" lists all the others. In addition to these man pages, the PCRE
  57. documentation is supplied in two other forms:
  58. 1. There are files called doc/pcre.txt, doc/pcregrep.txt, and
  59. doc/pcretest.txt in the source distribution. The first of these is a
  60. concatenation of the text forms of all the section 3 man pages except
  61. those that summarize individual functions. The other two are the text
  62. forms of the section 1 man pages for the pcregrep and pcretest commands.
  63. These text forms are provided for ease of scanning with text editors or
  64. similar tools. They are installed in <prefix>/share/doc/pcre, where
  65. <prefix> is the installation prefix (defaulting to /usr/local).
  66. 2. A set of files containing all the documentation in HTML form, hyperlinked
  67. in various ways, and rooted in a file called index.html, is distributed in
  68. doc/html and installed in <prefix>/share/doc/pcre/html.
  69. Contributions by users of PCRE
  70. ------------------------------
  71. You can find contributions from PCRE users in the directory
  72. ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/Contrib
  73. There is a README file giving brief descriptions of what they are. Some are
  74. complete in themselves; others are pointers to URLs containing relevant files.
  75. Some of this material is likely to be well out-of-date. Several of the earlier
  76. contributions provided support for compiling PCRE on various flavours of
  77. Windows (I myself do not use Windows). Nowadays there is more Windows support
  78. in the standard distribution, so these contibutions have been archived.
  79. Building PCRE on non-Unix systems
  80. ---------------------------------
  81. For a non-Unix system, please read the comments in the file NON-UNIX-USE,
  82. though if your system supports the use of "configure" and "make" you may be
  83. able to build PCRE in the same way as for Unix-like systems. PCRE can also be
  84. configured in many platform environments using the GUI facility of CMake's
  85. CMakeSetup. It creates Makefiles, solution files, etc.
  86. PCRE has been compiled on many different operating systems. It should be
  87. straightforward to build PCRE on any system that has a Standard C compiler and
  88. library, because it uses only Standard C functions.
  89. Building PCRE on Unix-like systems
  90. ----------------------------------
  91. If you are using HP's ANSI C++ compiler (aCC), please see the special note
  92. in the section entitled "Using HP's ANSI C++ compiler (aCC)" below.
  93. The following instructions assume the use of the widely used "configure, make,
  94. make install" process. There is also support for CMake in the PCRE
  95. distribution; there are some comments about using CMake in the NON-UNIX-USE
  96. file, though it can also be used in Unix-like systems.
  97. To build PCRE on a Unix-like system, first run the "configure" command from the
  98. PCRE distribution directory, with your current directory set to the directory
  99. where you want the files to be created. This command is a standard GNU
  100. "autoconf" configuration script, for which generic instructions are supplied in
  101. the file INSTALL.
  102. Most commonly, people build PCRE within its own distribution directory, and in
  103. this case, on many systems, just running "./configure" is sufficient. However,
  104. the usual methods of changing standard defaults are available. For example:
  105. CFLAGS='-O2 -Wall' ./configure --prefix=/opt/local
  106. specifies that the C compiler should be run with the flags '-O2 -Wall' instead
  107. of the default, and that "make install" should install PCRE under /opt/local
  108. instead of the default /usr/local.
  109. If you want to build in a different directory, just run "configure" with that
  110. directory as current. For example, suppose you have unpacked the PCRE source
  111. into /source/pcre/pcre-xxx, but you want to build it in /build/pcre/pcre-xxx:
  112. cd /build/pcre/pcre-xxx
  113. /source/pcre/pcre-xxx/configure
  114. PCRE is written in C and is normally compiled as a C library. However, it is
  115. possible to build it as a C++ library, though the provided building apparatus
  116. does not have any features to support this.
  117. There are some optional features that can be included or omitted from the PCRE
  118. library. You can read more about them in the pcrebuild man page.
  119. . If you want to suppress the building of the C++ wrapper library, you can add
  120. --disable-cpp to the "configure" command. Otherwise, when "configure" is run,
  121. it will try to find a C++ compiler and C++ header files, and if it succeeds,
  122. it will try to build the C++ wrapper.
  123. . If you want to make use of the support for UTF-8 character strings in PCRE,
  124. you must add --enable-utf8 to the "configure" command. Without it, the code
  125. for handling UTF-8 is not included in the library. (Even when included, it
  126. still has to be enabled by an option at run time.)
  127. . If, in addition to support for UTF-8 character strings, you want to include
  128. support for the \P, \p, and \X sequences that recognize Unicode character
  129. properties, you must add --enable-unicode-properties to the "configure"
  130. command. This adds about 30K to the size of the library (in the form of a
  131. property table); only the basic two-letter properties such as Lu are
  132. supported.
  133. . You can build PCRE to recognize either CR or LF or the sequence CRLF or any
  134. of the preceding, or any of the Unicode newline sequences as indicating the
  135. end of a line. Whatever you specify at build time is the default; the caller
  136. of PCRE can change the selection at run time. The default newline indicator
  137. is a single LF character (the Unix standard). You can specify the default
  138. newline indicator by adding --enable-newline-is-cr or --enable-newline-is-lf
  139. or --enable-newline-is-crlf or --enable-newline-is-anycrlf or
  140. --enable-newline-is-any to the "configure" command, respectively.
  141. If you specify --enable-newline-is-cr or --enable-newline-is-crlf, some of
  142. the standard tests will fail, because the lines in the test files end with
  143. LF. Even if the files are edited to change the line endings, there are likely
  144. to be some failures. With --enable-newline-is-anycrlf or
  145. --enable-newline-is-any, many tests should succeed, but there may be some
  146. failures.
  147. . By default, the sequence \R in a pattern matches any Unicode line ending
  148. sequence. This is independent of the option specifying what PCRE considers to
  149. be the end of a line (see above). However, the caller of PCRE can restrict \R
  150. to match only CR, LF, or CRLF. You can make this the default by adding
  151. --enable-bsr-anycrlf to the "configure" command (bsr = "backslash R").
  152. . When called via the POSIX interface, PCRE uses malloc() to get additional
  153. storage for processing capturing parentheses if there are more than 10 of
  154. them in a pattern. You can increase this threshold by setting, for example,
  155. --with-posix-malloc-threshold=20
  156. on the "configure" command.
  157. . PCRE has a counter that can be set to limit the amount of resources it uses.
  158. If the limit is exceeded during a match, the match fails. The default is ten
  159. million. You can change the default by setting, for example,
  160. --with-match-limit=500000
  161. on the "configure" command. This is just the default; individual calls to
  162. pcre_exec() can supply their own value. There is more discussion on the
  163. pcreapi man page.
  164. . There is a separate counter that limits the depth of recursive function calls
  165. during a matching process. This also has a default of ten million, which is
  166. essentially "unlimited". You can change the default by setting, for example,
  167. --with-match-limit-recursion=500000
  168. Recursive function calls use up the runtime stack; running out of stack can
  169. cause programs to crash in strange ways. There is a discussion about stack
  170. sizes in the pcrestack man page.
  171. . The default maximum compiled pattern size is around 64K. You can increase
  172. this by adding --with-link-size=3 to the "configure" command. You can
  173. increase it even more by setting --with-link-size=4, but this is unlikely
  174. ever to be necessary. Increasing the internal link size will reduce
  175. performance.
  176. . You can build PCRE so that its internal match() function that is called from
  177. pcre_exec() does not call itself recursively. Instead, it uses memory blocks
  178. obtained from the heap via the special functions pcre_stack_malloc() and
  179. pcre_stack_free() to save data that would otherwise be saved on the stack. To
  180. build PCRE like this, use
  181. --disable-stack-for-recursion
  182. on the "configure" command. PCRE runs more slowly in this mode, but it may be
  183. necessary in environments with limited stack sizes. This applies only to the
  184. pcre_exec() function; it does not apply to pcre_dfa_exec(), which does not
  185. use deeply nested recursion. There is a discussion about stack sizes in the
  186. pcrestack man page.
  187. . For speed, PCRE uses four tables for manipulating and identifying characters
  188. whose code point values are less than 256. By default, it uses a set of
  189. tables for ASCII encoding that is part of the distribution. If you specify
  190. --enable-rebuild-chartables
  191. a program called dftables is compiled and run in the default C locale when
  192. you obey "make". It builds a source file called pcre_chartables.c. If you do
  193. not specify this option, pcre_chartables.c is created as a copy of
  194. pcre_chartables.c.dist. See "Character tables" below for further information.
  195. . It is possible to compile PCRE for use on systems that use EBCDIC as their
  196. default character code (as opposed to ASCII) by specifying
  197. --enable-ebcdic
  198. This automatically implies --enable-rebuild-chartables (see above).
  199. . It is possible to compile pcregrep to use libz and/or libbz2, in order to
  200. read .gz and .bz2 files (respectively), by specifying one or both of
  201. --enable-pcregrep-libz
  202. --enable-pcregrep-libbz2
  203. Of course, the relevant libraries must be installed on your system.
  204. . It is possible to compile pcretest so that it links with the libreadline
  205. library, by specifying
  206. --enable-pcretest-libreadline
  207. If this is done, when pcretest's input is from a terminal, it reads it using
  208. the readline() function. This provides line-editing and history facilities.
  209. Note that libreadline is GPL-licenced, so if you distribute a binary of
  210. pcretest linked in this way, there may be licensing issues.
  211. Setting this option causes the -lreadline option to be added to the pcretest
  212. build. In many operating environments with a sytem-installed readline
  213. library this is sufficient. However, in some environments (e.g. if an
  214. unmodified distribution version of readline is in use), it may be necessary
  215. to specify something like LIBS="-lncurses" as well. This is because, to quote
  216. the readline INSTALL, "Readline uses the termcap functions, but does not link
  217. with the termcap or curses library itself, allowing applications which link
  218. with readline the to choose an appropriate library."
  219. The "configure" script builds the following files for the basic C library:
  220. . Makefile is the makefile that builds the library
  221. . config.h contains build-time configuration options for the library
  222. . pcre.h is the public PCRE header file
  223. . pcre-config is a script that shows the settings of "configure" options
  224. . libpcre.pc is data for the pkg-config command
  225. . libtool is a script that builds shared and/or static libraries
  226. . RunTest is a script for running tests on the basic C library
  227. . RunGrepTest is a script for running tests on the pcregrep command
  228. Versions of config.h and pcre.h are distributed in the PCRE tarballs under
  229. the names config.h.generic and pcre.h.generic. These are provided for the
  230. benefit of those who have to built PCRE without the benefit of "configure". If
  231. you use "configure", the .generic versions are not used.
  232. If a C++ compiler is found, the following files are also built:
  233. . libpcrecpp.pc is data for the pkg-config command
  234. . pcrecpparg.h is a header file for programs that call PCRE via the C++ wrapper
  235. . pcre_stringpiece.h is the header for the C++ "stringpiece" functions
  236. The "configure" script also creates config.status, which is an executable
  237. script that can be run to recreate the configuration, and config.log, which
  238. contains compiler output from tests that "configure" runs.
  239. Once "configure" has run, you can run "make". It builds two libraries, called
  240. libpcre and libpcreposix, a test program called pcretest, and the pcregrep
  241. command. If a C++ compiler was found on your system, "make" also builds the C++
  242. wrapper library, which is called libpcrecpp, and some test programs called
  243. pcrecpp_unittest, pcre_scanner_unittest, and pcre_stringpiece_unittest.
  244. Building the C++ wrapper can be disabled by adding --disable-cpp to the
  245. "configure" command.
  246. The command "make check" runs all the appropriate tests. Details of the PCRE
  247. tests are given below in a separate section of this document.
  248. You can use "make install" to install PCRE into live directories on your
  249. system. The following are installed (file names are all relative to the
  250. <prefix> that is set when "configure" is run):
  251. Commands (bin):
  252. pcretest
  253. pcregrep
  254. pcre-config
  255. Libraries (lib):
  256. libpcre
  257. libpcreposix
  258. libpcrecpp (if C++ support is enabled)
  259. Configuration information (lib/pkgconfig):
  260. libpcre.pc
  261. libpcrecpp.pc (if C++ support is enabled)
  262. Header files (include):
  263. pcre.h
  264. pcreposix.h
  265. pcre_scanner.h )
  266. pcre_stringpiece.h ) if C++ support is enabled
  267. pcrecpp.h )
  268. pcrecpparg.h )
  269. Man pages (share/man/man{1,3}):
  270. pcregrep.1
  271. pcretest.1
  272. pcre.3
  273. pcre*.3 (lots more pages, all starting "pcre")
  274. HTML documentation (share/doc/pcre/html):
  275. index.html
  276. *.html (lots more pages, hyperlinked from index.html)
  277. Text file documentation (share/doc/pcre):
  278. AUTHORS
  279. COPYING
  280. ChangeLog
  281. LICENCE
  282. NEWS
  283. README
  284. pcre.txt (a concatenation of the man(3) pages)
  285. pcretest.txt the pcretest man page
  286. pcregrep.txt the pcregrep man page
  287. If you want to remove PCRE from your system, you can run "make uninstall".
  288. This removes all the files that "make install" installed. However, it does not
  289. remove any directories, because these are often shared with other programs.
  290. Retrieving configuration information on Unix-like systems
  291. ---------------------------------------------------------
  292. Running "make install" installs the command pcre-config, which can be used to
  293. recall information about the PCRE configuration and installation. For example:
  294. pcre-config --version
  295. prints the version number, and
  296. pcre-config --libs
  297. outputs information about where the library is installed. This command can be
  298. included in makefiles for programs that use PCRE, saving the programmer from
  299. having to remember too many details.
  300. The pkg-config command is another system for saving and retrieving information
  301. about installed libraries. Instead of separate commands for each library, a
  302. single command is used. For example:
  303. pkg-config --cflags pcre
  304. The data is held in *.pc files that are installed in a directory called
  305. <prefix>/lib/pkgconfig.
  306. Shared libraries on Unix-like systems
  307. -------------------------------------
  308. The default distribution builds PCRE as shared libraries and static libraries,
  309. as long as the operating system supports shared libraries. Shared library
  310. support relies on the "libtool" script which is built as part of the
  311. "configure" process.
  312. The libtool script is used to compile and link both shared and static
  313. libraries. They are placed in a subdirectory called .libs when they are newly
  314. built. The programs pcretest and pcregrep are built to use these uninstalled
  315. libraries (by means of wrapper scripts in the case of shared libraries). When
  316. you use "make install" to install shared libraries, pcregrep and pcretest are
  317. automatically re-built to use the newly installed shared libraries before being
  318. installed themselves. However, the versions left in the build directory still
  319. use the uninstalled libraries.
  320. To build PCRE using static libraries only you must use --disable-shared when
  321. configuring it. For example:
  322. ./configure --prefix=/usr/gnu --disable-shared
  323. Then run "make" in the usual way. Similarly, you can use --disable-static to
  324. build only shared libraries.
  325. Cross-compiling on Unix-like systems
  326. ------------------------------------
  327. You can specify CC and CFLAGS in the normal way to the "configure" command, in
  328. order to cross-compile PCRE for some other host. However, you should NOT
  329. specify --enable-rebuild-chartables, because if you do, the dftables.c source
  330. file is compiled and run on the local host, in order to generate the inbuilt
  331. character tables (the pcre_chartables.c file). This will probably not work,
  332. because dftables.c needs to be compiled with the local compiler, not the cross
  333. compiler.
  334. When --enable-rebuild-chartables is not specified, pcre_chartables.c is created
  335. by making a copy of pcre_chartables.c.dist, which is a default set of tables
  336. that assumes ASCII code. Cross-compiling with the default tables should not be
  337. a problem.
  338. If you need to modify the character tables when cross-compiling, you should
  339. move pcre_chartables.c.dist out of the way, then compile dftables.c by hand and
  340. run it on the local host to make a new version of pcre_chartables.c.dist.
  341. Then when you cross-compile PCRE this new version of the tables will be used.
  342. Using HP's ANSI C++ compiler (aCC)
  343. ----------------------------------
  344. Unless C++ support is disabled by specifying the "--disable-cpp" option of the
  345. "configure" script, you must include the "-AA" option in the CXXFLAGS
  346. environment variable in order for the C++ components to compile correctly.
  347. Also, note that the aCC compiler on PA-RISC platforms may have a defect whereby
  348. needed libraries fail to get included when specifying the "-AA" compiler
  349. option. If you experience unresolved symbols when linking the C++ programs,
  350. use the workaround of specifying the following environment variable prior to
  351. running the "configure" script:
  352. CXXLDFLAGS="-lstd_v2 -lCsup_v2"
  353. Making new tarballs
  354. -------------------
  355. The command "make dist" creates three PCRE tarballs, in tar.gz, tar.bz2, and
  356. zip formats. The command "make distcheck" does the same, but then does a trial
  357. build of the new distribution to ensure that it works.
  358. If you have modified any of the man page sources in the doc directory, you
  359. should first run the PrepareRelease script before making a distribution. This
  360. script creates the .txt and HTML forms of the documentation from the man pages.
  361. Testing PCRE
  362. ------------
  363. To test the basic PCRE library on a Unix system, run the RunTest script that is
  364. created by the configuring process. There is also a script called RunGrepTest
  365. that tests the options of the pcregrep command. If the C++ wrapper library is
  366. built, three test programs called pcrecpp_unittest, pcre_scanner_unittest, and
  367. pcre_stringpiece_unittest are also built.
  368. Both the scripts and all the program tests are run if you obey "make check" or
  369. "make test". For other systems, see the instructions in NON-UNIX-USE.
  370. The RunTest script runs the pcretest test program (which is documented in its
  371. own man page) on each of the testinput files in the testdata directory in
  372. turn, and compares the output with the contents of the corresponding testoutput
  373. files. A file called testtry is used to hold the main output from pcretest
  374. (testsavedregex is also used as a working file). To run pcretest on just one of
  375. the test files, give its number as an argument to RunTest, for example:
  376. RunTest 2
  377. The first test file can also be fed directly into the perltest.pl script to
  378. check that Perl gives the same results. The only difference you should see is
  379. in the first few lines, where the Perl version is given instead of the PCRE
  380. version.
  381. The second set of tests check pcre_fullinfo(), pcre_info(), pcre_study(),
  382. pcre_copy_substring(), pcre_get_substring(), pcre_get_substring_list(), error
  383. detection, and run-time flags that are specific to PCRE, as well as the POSIX
  384. wrapper API. It also uses the debugging flags to check some of the internals of
  385. pcre_compile().
  386. If you build PCRE with a locale setting that is not the standard C locale, the
  387. character tables may be different (see next paragraph). In some cases, this may
  388. cause failures in the second set of tests. For example, in a locale where the
  389. isprint() function yields TRUE for characters in the range 128-255, the use of
  390. [:isascii:] inside a character class defines a different set of characters, and
  391. this shows up in this test as a difference in the compiled code, which is being
  392. listed for checking. Where the comparison test output contains [\x00-\x7f] the
  393. test will contain [\x00-\xff], and similarly in some other cases. This is not a
  394. bug in PCRE.
  395. The third set of tests checks pcre_maketables(), the facility for building a
  396. set of character tables for a specific locale and using them instead of the
  397. default tables. The tests make use of the "fr_FR" (French) locale. Before
  398. running the test, the script checks for the presence of this locale by running
  399. the "locale" command. If that command fails, or if it doesn't include "fr_FR"
  400. in the list of available locales, the third test cannot be run, and a comment
  401. is output to say why. If running this test produces instances of the error
  402. ** Failed to set locale "fr_FR"
  403. in the comparison output, it means that locale is not available on your system,
  404. despite being listed by "locale". This does not mean that PCRE is broken.
  405. [If you are trying to run this test on Windows, you may be able to get it to
  406. work by changing "fr_FR" to "french" everywhere it occurs. Alternatively, use
  407. RunTest.bat. The version of RunTest.bat included with PCRE 7.4 and above uses
  408. Windows versions of test 2. More info on using RunTest.bat is included in the
  409. document entitled NON-UNIX-USE.]
  410. The fourth test checks the UTF-8 support. It is not run automatically unless
  411. PCRE is built with UTF-8 support. To do this you must set --enable-utf8 when
  412. running "configure". This file can be also fed directly to the perltest script,
  413. provided you are running Perl 5.8 or higher. (For Perl 5.6, a small patch,
  414. commented in the script, can be be used.)
  415. The fifth test checks error handling with UTF-8 encoding, and internal UTF-8
  416. features of PCRE that are not relevant to Perl.
  417. The sixth test checks the support for Unicode character properties. It it not
  418. run automatically unless PCRE is built with Unicode property support. To to
  419. this you must set --enable-unicode-properties when running "configure".
  420. The seventh, eighth, and ninth tests check the pcre_dfa_exec() alternative
  421. matching function, in non-UTF-8 mode, UTF-8 mode, and UTF-8 mode with Unicode
  422. property support, respectively. The eighth and ninth tests are not run
  423. automatically unless PCRE is build with the relevant support.
  424. Character tables
  425. ----------------
  426. For speed, PCRE uses four tables for manipulating and identifying characters
  427. whose code point values are less than 256. The final argument of the
  428. pcre_compile() function is a pointer to a block of memory containing the
  429. concatenated tables. A call to pcre_maketables() can be used to generate a set
  430. of tables in the current locale. If the final argument for pcre_compile() is
  431. passed as NULL, a set of default tables that is built into the binary is used.
  432. The source file called pcre_chartables.c contains the default set of tables. By
  433. default, this is created as a copy of pcre_chartables.c.dist, which contains
  434. tables for ASCII coding. However, if --enable-rebuild-chartables is specified
  435. for ./configure, a different version of pcre_chartables.c is built by the
  436. program dftables (compiled from dftables.c), which uses the ANSI C character
  437. handling functions such as isalnum(), isalpha(), isupper(), islower(), etc. to
  438. build the table sources. This means that the default C locale which is set for
  439. your system will control the contents of these default tables. You can change
  440. the default tables by editing pcre_chartables.c and then re-building PCRE. If
  441. you do this, you should take care to ensure that the file does not get
  442. automatically re-generated. The best way to do this is to move
  443. pcre_chartables.c.dist out of the way and replace it with your customized
  444. tables.
  445. When the dftables program is run as a result of --enable-rebuild-chartables,
  446. it uses the default C locale that is set on your system. It does not pay
  447. attention to the LC_xxx environment variables. In other words, it uses the
  448. system's default locale rather than whatever the compiling user happens to have
  449. set. If you really do want to build a source set of character tables in a
  450. locale that is specified by the LC_xxx variables, you can run the dftables
  451. program by hand with the -L option. For example:
  452. ./dftables -L pcre_chartables.c.special
  453. The first two 256-byte tables provide lower casing and case flipping functions,
  454. respectively. The next table consists of three 32-byte bit maps which identify
  455. digits, "word" characters, and white space, respectively. These are used when
  456. building 32-byte bit maps that represent character classes for code points less
  457. than 256.
  458. The final 256-byte table has bits indicating various character types, as
  459. follows:
  460. 1 white space character
  461. 2 letter
  462. 4 decimal digit
  463. 8 hexadecimal digit
  464. 16 alphanumeric or '_'
  465. 128 regular expression metacharacter or binary zero
  466. You should not alter the set of characters that contain the 128 bit, as that
  467. will cause PCRE to malfunction.
  468. File manifest
  469. -------------
  470. The distribution should contain the following files:
  471. (A) Source files of the PCRE library functions and their headers:
  472. dftables.c auxiliary program for building pcre_chartables.c
  473. when --enable-rebuild-chartables is specified
  474. pcre_chartables.c.dist a default set of character tables that assume ASCII
  475. coding; used, unless --enable-rebuild-chartables is
  476. specified, by copying to pcre_chartables.c
  477. pcreposix.c )
  478. pcre_compile.c )
  479. pcre_config.c )
  480. pcre_dfa_exec.c )
  481. pcre_exec.c )
  482. pcre_fullinfo.c )
  483. pcre_get.c ) sources for the functions in the library,
  484. pcre_globals.c ) and some internal functions that they use
  485. pcre_info.c )
  486. pcre_maketables.c )
  487. pcre_newline.c )
  488. pcre_ord2utf8.c )
  489. pcre_refcount.c )
  490. pcre_study.c )
  491. pcre_tables.c )
  492. pcre_try_flipped.c )
  493. pcre_ucd.c )
  494. pcre_valid_utf8.c )
  495. pcre_version.c )
  496. pcre_xclass.c )
  497. pcre_printint.src ) debugging function that is #included in pcretest,
  498. ) and can also be #included in pcre_compile()
  499. pcre.h.in template for pcre.h when built by "configure"
  500. pcreposix.h header for the external POSIX wrapper API
  501. pcre_internal.h header for internal use
  502. ucp.h header for Unicode property handling
  503. config.h.in template for config.h, which is built by "configure"
  504. pcrecpp.h public header file for the C++ wrapper
  505. pcrecpparg.h.in template for another C++ header file
  506. pcre_scanner.h public header file for C++ scanner functions
  507. pcrecpp.cc )
  508. pcre_scanner.cc ) source for the C++ wrapper library
  509. pcre_stringpiece.h.in template for pcre_stringpiece.h, the header for the
  510. C++ stringpiece functions
  511. pcre_stringpiece.cc source for the C++ stringpiece functions
  512. (B) Source files for programs that use PCRE:
  513. pcredemo.c simple demonstration of coding calls to PCRE
  514. pcregrep.c source of a grep utility that uses PCRE
  515. pcretest.c comprehensive test program
  516. (C) Auxiliary files:
  517. 132html script to turn "man" pages into HTML
  518. AUTHORS information about the author of PCRE
  519. ChangeLog log of changes to the code
  520. CleanTxt script to clean nroff output for txt man pages
  521. Detrail script to remove trailing spaces
  522. HACKING some notes about the internals of PCRE
  523. INSTALL generic installation instructions
  524. LICENCE conditions for the use of PCRE
  525. COPYING the same, using GNU's standard name
  526. Makefile.in ) template for Unix Makefile, which is built by
  527. ) "configure"
  528. Makefile.am ) the automake input that was used to create
  529. ) Makefile.in
  530. NEWS important changes in this release
  531. NON-UNIX-USE notes on building PCRE on non-Unix systems
  532. PrepareRelease script to make preparations for "make dist"
  533. README this file
  534. RunTest a Unix shell script for running tests
  535. RunGrepTest a Unix shell script for pcregrep tests
  536. aclocal.m4 m4 macros (generated by "aclocal")
  537. config.guess ) files used by libtool,
  538. config.sub ) used only when building a shared library
  539. configure a configuring shell script (built by autoconf)
  540. configure.ac ) the autoconf input that was used to build
  541. ) "configure" and config.h
  542. depcomp ) script to find program dependencies, generated by
  543. ) automake
  544. doc/*.3 man page sources for the PCRE functions
  545. doc/*.1 man page sources for pcregrep and pcretest
  546. doc/index.html.src the base HTML page
  547. doc/html/* HTML documentation
  548. doc/pcre.txt plain text version of the man pages
  549. doc/pcretest.txt plain text documentation of test program
  550. doc/perltest.txt plain text documentation of Perl test program
  551. install-sh a shell script for installing files
  552. libpcre.pc.in template for libpcre.pc for pkg-config
  553. libpcrecpp.pc.in template for libpcrecpp.pc for pkg-config
  554. ltmain.sh file used to build a libtool script
  555. missing ) common stub for a few missing GNU programs while
  556. ) installing, generated by automake
  557. mkinstalldirs script for making install directories
  558. perltest.pl Perl test program
  559. pcre-config.in source of script which retains PCRE information
  560. pcrecpp_unittest.cc )
  561. pcre_scanner_unittest.cc ) test programs for the C++ wrapper
  562. pcre_stringpiece_unittest.cc )
  563. testdata/testinput* test data for main library tests
  564. testdata/testoutput* expected test results
  565. testdata/grep* input and output for pcregrep tests
  566. (D) Auxiliary files for cmake support
  567. cmake/COPYING-CMAKE-SCRIPTS
  568. cmake/FindPackageHandleStandardArgs.cmake
  569. cmake/FindReadline.cmake
  570. CMakeLists.txt
  571. config-cmake.h.in
  572. (E) Auxiliary files for VPASCAL
  573. makevp.bat
  574. makevp_c.txt
  575. makevp_l.txt
  576. pcregexp.pas
  577. (F) Auxiliary files for building PCRE "by hand"
  578. pcre.h.generic ) a version of the public PCRE header file
  579. ) for use in non-"configure" environments
  580. config.h.generic ) a version of config.h for use in non-"configure"
  581. ) environments
  582. (F) Miscellaneous
  583. RunTest.bat a script for running tests under Windows
  584. Philip Hazel
  585. Email local part: ph10
  586. Email domain: cam.ac.uk
  587. Last updated: 05 September 2008