ViewVC logotype

Contents of /code/trunk/README

Parent Directory Parent Directory | Revision Log Revision Log

Revision 109 - (show annotations)
Wed Mar 7 15:35:57 2007 UTC (14 years, 6 months ago) by ph10
File size: 28469 byte(s)
Update the README file.
1 README file for PCRE (Perl-compatible regular expression library)
2 -----------------------------------------------------------------
4 The latest release of PCRE is always available from
6 ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre-xxx.tar.gz
8 Please read the NEWS file if you are upgrading from a previous release.
9 The contents of this README file are:
11 The PCRE APIs
12 Documentation for PCRE
13 Contributions by users of PCRE
14 Building PCRE on non-Unix systems
15 Building PCRE on a Unix-like system
16 Retrieving configuration information on a Unix-like system
17 Shared libraries on Unix-like systems
18 Cross-compiling on a Unix-like system
19 Using HP's ANSI C++ compiler (aCC)
20 Testing PCRE
21 Character tables
22 File manifest
25 The PCRE APIs
26 -------------
28 PCRE is written in C, and it has its own API. The distribution now includes a
29 set of C++ wrapper functions, courtesy of Google Inc. (see the pcrecpp man page
30 for details).
32 Also included in the distribution are a set of C wrapper functions that are
33 based on the POSIX API. These end up in the library called libpcreposix. Note
34 that this just provides a POSIX calling interface to PCRE; the regular
35 expressions themselves still follow Perl syntax and semantics. The POSIX API is
36 restricted, and does not give full access to all of PCRE's facilities.
38 The header file for the POSIX-style functions is called pcreposix.h. The
39 official POSIX name is regex.h, but I did not want to risk possible problems
40 with existing files of that name by distributing it that way. To use PCRE with
41 an existing program that uses the POSIX API, pcreposix.h will have to be
42 renamed or pointed at by a link.
44 If you are using the POSIX interface to PCRE and there is already a POSIX regex
45 library installed on your system, as well as worrying about the regex.h header
46 file (as mentioned above), you must also take care when linking programs to
47 ensure that they link with PCRE's libpcreposix library. Otherwise they may pick
48 up the POSIX functions of the same name from the other library.
50 One way of avoiding this confusion is to compile PCRE with the addition of
51 -Dregcomp=PCREregcomp (and similarly for the other functions) to the compiler
52 flags (CFLAGS if you are using "configure" -- see below). This has the effect
53 of renaming the functions so that the names no longer clash. Of course, you
54 have to do the same thing for your applications, or write them using the new
55 names.
58 Documentation for PCRE
59 ----------------------
61 If you install PCRE in the normal way, you will end up with an installed set of
62 man pages whose names all start with "pcre". The one that is just called "pcre"
63 lists all the others. In addition to these man pages, the PCRE documentation is
64 supplied in two other forms:
66 1. There are files called doc/pcre.txt, doc/pcregrep.txt, and
67 doc/pcretest.txt in the source distribution. The first of these is a
68 concatenation of the text forms of all the section 3 man pages except
69 those that summarize individual functions. The other two are the text
70 forms of the section 1 man pages for the pcregrep and pcretest commands.
71 These text forms are provided for ease of scanning with text editors or
72 similar tools.
74 2. A set of files containing all the documentation in HTML form, hyperlinked
75 in various ways, and rooted in a file called index.html, is installed in
76 the directory <prefix>/share/doc/pcre/html, where <prefix> is the
77 installation prefix (defaulting to /usr/local).
80 Contributions by users of PCRE
81 ------------------------------
83 You can find contributions from PCRE users in the directory
85 ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/Contrib
87 where there is also a README file giving brief descriptions of what they are.
88 Some are complete in themselves; others are pointers to URLs containing
89 relevant files. Some of this material is likely to be well out-of-date. In
90 particular, several of the contributions provide support for compiling PCRE on
91 various flavours of Windows (I myself do not use Windows), but it is hoped that
92 more Windows support will find its way into the standard distribution.
95 Building PCRE on non-Unix systems
96 ---------------------------------
98 For a non-Unix system, read the comments in the file NON-UNIX-USE, though if
99 the system supports the use of "configure" and "make" you may be able to build
100 PCRE in the same way as for Unix-like systems.
102 PCRE has been compiled on many different operating systems. It should be
103 straightforward to build PCRE on any system that has a Standard C compiler and
104 library, because it uses only Standard C functions.
107 Building PCRE on a Unix-like system
108 -----------------------------------
110 If you are using HP's ANSI C++ compiler (aCC), please see the special note
111 in the section entitled "Using HP's ANSI C++ compiler (aCC)" below.
113 To build PCRE on a Unix-like system, first run the "configure" command from the
114 PCRE distribution directory, with your current directory set to the directory
115 where you want the files to be created. This command is a standard GNU
116 "autoconf" configuration script, for which generic instructions are supplied in
119 Most commonly, people build PCRE within its own distribution directory, and in
120 this case, on many systems, just running "./configure" is sufficient. However,
121 the usual methods of changing standard defaults are available. For example:
123 CFLAGS='-O2 -Wall' ./configure --prefix=/opt/local
125 specifies that the C compiler should be run with the flags '-O2 -Wall' instead
126 of the default, and that "make install" should install PCRE under /opt/local
127 instead of the default /usr/local.
129 If you want to build in a different directory, just run "configure" with that
130 directory as current. For example, suppose you have unpacked the PCRE source
131 into /source/pcre/pcre-xxx, but you want to build it in /build/pcre/pcre-xxx:
133 cd /build/pcre/pcre-xxx
134 /source/pcre/pcre-xxx/configure
136 PCRE is written in C and is normally compiled as a C library. However, it is
137 possible to build it as a C++ library, though the provided building apparatus
138 does not have any features to support this.
140 There are some optional features that can be included or omitted from the PCRE
141 library. You can read more about them in the pcrebuild man page.
143 . If you want to suppress the building of the C++ wrapper library, you can add
144 --disable-cpp to the "configure" command. Otherwise, when "configure" is run,
145 will try to find a C++ compiler and C++ header files, and if it succeeds, it
146 will try to build the C++ wrapper.
148 . If you want to make use of the support for UTF-8 character strings in PCRE,
149 you must add --enable-utf8 to the "configure" command. Without it, the code
150 for handling UTF-8 is not included in the library. (Even when included, it
151 still has to be enabled by an option at run time.)
153 . If, in addition to support for UTF-8 character strings, you want to include
154 support for the \P, \p, and \X sequences that recognize Unicode character
155 properties, you must add --enable-unicode-properties to the "configure"
156 command. This adds about 30K to the size of the library (in the form of a
157 property table); only the basic two-letter properties such as Lu are
158 supported.
160 . You can build PCRE to recognize either CR or LF or the sequence CRLF or any
161 of the Unicode newline sequences as indicating the end of a line. Whatever
162 you specify at build time is the default; the caller of PCRE can change the
163 selection at run time. The default newline indicator is a single LF character
164 (the Unix standard). You can specify the default newline indicator by adding
165 --newline-is-cr or --newline-is-lf or --newline-is-crlf or --newline-is-any
166 to the "configure" command, respectively.
168 If you specify --newline-is-cr or --newline-is-crlf, some of the standard
169 tests will fail, because the lines in the test files end with LF. Even if
170 the files are edited to change the line endings, there are likely to be some
171 failures. With --newline-is-any, many tests should succeed, but there may be
172 some failures.
174 . When called via the POSIX interface, PCRE uses malloc() to get additional
175 storage for processing capturing parentheses if there are more than 10 of
176 them. You can increase this threshold by setting, for example,
178 --with-posix-malloc-threshold=20
180 on the "configure" command.
182 . PCRE has a counter that can be set to limit the amount of resources it uses.
183 If the limit is exceeded during a match, the match fails. The default is ten
184 million. You can change the default by setting, for example,
186 --with-match-limit=500000
188 on the "configure" command. This is just the default; individual calls to
189 pcre_exec() can supply their own value. There is discussion on the pcreapi
190 man page.
192 . There is a separate counter that limits the depth of recursive function calls
193 during a matching process. This also has a default of ten million, which is
194 essentially "unlimited". You can change the default by setting, for example,
196 --with-match-limit-recursion=500000
198 Recursive function calls use up the runtime stack; running out of stack can
199 cause programs to crash in strange ways. There is a discussion about stack
200 sizes in the pcrestack man page.
202 . The default maximum compiled pattern size is around 64K. You can increase
203 this by adding --with-link-size=3 to the "configure" command. You can
204 increase it even more by setting --with-link-size=4, but this is unlikely
205 ever to be necessary. If you build PCRE with an increased link size, test 2
206 (and 5 if you are using UTF-8) will fail. Part of the output of these tests
207 is a representation of the compiled pattern, and this changes with the link
208 size.
210 . You can build PCRE so that its internal match() function that is called from
211 pcre_exec() does not call itself recursively. Instead, it uses blocks of data
212 from the heap via special functions pcre_stack_malloc() and pcre_stack_free()
213 to save data that would otherwise be saved on the stack. To build PCRE like
214 this, use
216 --disable-stack-for-recursion
218 on the "configure" command. PCRE runs more slowly in this mode, but it may be
219 necessary in environments with limited stack sizes. This applies only to the
220 pcre_exec() function; it does not apply to pcre_dfa_exec(), which does not
221 use deeply nested recursion.
223 The "configure" script builds the following files for the basic C library:
225 . Makefile is the makefile that builds the library
226 . config.h contains build-time configuration options for the library
227 . pcre.h is the public PCRE header file
228 . pcre-config is a script that shows the settings of "configure" options
229 . libpcre.pc is data for the pkg-config command
230 . libtool is a script that builds shared and/or static libraries
231 . RunTest is a script for running tests on the basic C library
232 . RunGrepTest is a script for running tests on the pcregrep command
234 Versions of config.h and pcre.h are distributed in the PCRE tarballs. These are
235 provided for the benefit of those who have to compile PCRE without the benefit
236 of "configure". If you use "configure", the distributed copies are replaced.
238 If a C++ compiler is found, the following files are also built:
240 . libpcrecpp.pc is data for the pkg-config command
241 . pcrecpparg.h is a header file for programs that call PCRE via the C++ wrapper
242 . pcre_stringpiece.h is the header for the C++ "stringpiece" functions
244 The "configure" script also creates config.status, which is an executable
245 script that can be run to recreate the configuration, and config.log, which
246 contains compiler output from tests that "configure" runs.
248 Once "configure" has run, you can run "make". It builds two libraries, called
249 libpcre and libpcreposix, a test program called pcretest, a demonstration
250 program called pcredemo, and the pcregrep command. If a C++ compiler was found
251 on your system, it also builds the C++ wrapper library, which is called
252 libpcrecpp, and some test programs called pcrecpp_unittest,
253 pcre_scanner_unittest, and pcre_stringpiece_unittest.
255 The command "make check" runs all the appropriate tests. Details of the PCRE
256 tests are given below in a separate section of this document.
258 You can use "make install" to install PCRE into live directories on your
259 system. The following are installed (file names are all relative to the
260 <prefix> that is set when "configure" is run):
262 Commands (bin):
263 pcretest
264 pcregrep
265 pcre-config
267 Libraries (lib):
268 libpcre
269 libpcreposix
270 libpcrecpp (if C++ support is enabled)
272 Configuration information (lib/pkgconfig):
273 libpcre.pc
274 libpcrecpp.ps (if C++ support is enabled)
276 Header files (include):
277 pcre.h
278 pcreposix.h
279 pcre_scanner.h )
280 pcre_stringpiece.h ) if C++ support is enabled
281 pcrecpp.h )
282 pcrecpparg.h )
284 Man pages (share/man/man{1,3}):
285 pcregrep.1
286 pcretest.1
287 pcre.3
288 pcre*.3 (lots more pages, all starting "pcre")
290 HTML documentation (share/doc/pcre/html):
291 index.html
292 *.html (lots more pages, hyperlinked from index.html)
294 Text file documentation (share/doc/pcre):
297 ChangeLog
301 NEWS
303 pcre.txt (a concatenation of the man(3) pages)
304 pcretest.txt the pcretest man page
305 pcregrep.txt the pcregrep man page
306 perltest.txt some information about the perltest.pl script
308 Note that the pcredemo program that is built by "configure" is *not* installed
309 anywhere. It is a demonstration for programmers wanting to use PCRE.
311 If you want to remove PCRE from your system, you can run "make uninstall".
312 This removes all the files that "make install" installed. However, it does not
313 remove any directories, because these are often shared with other programs.
316 Retrieving configuration information on a Unix-like system
317 ----------------------------------------------------------
319 Running "make install" installs the command pcre-config, which can be used to
320 recall information about the PCRE configuration and installation. For example:
322 pcre-config --version
324 prints the version number, and
326 pcre-config --libs
328 outputs information about where the library is installed. This command can be
329 included in makefiles for programs that use PCRE, saving the programmer from
330 having to remember too many details.
332 The pkg-config command is another system for saving and retrieving information
333 about installed libraries. Instead of separate commands for each library, a
334 single command is used. For example:
336 pkg-config --cflags pcre
338 The data is held in *.pc files that are installed in a directory called
339 <prefix>/lib/pkgconfig.
342 Shared libraries on Unix-like systems
343 -------------------------------------
345 The default distribution builds PCRE as shared libraries and static libraries,
346 as long as the operating system supports shared libraries. Shared library
347 support relies on the "libtool" script which is built as part of the
348 "configure" process.
350 The libtool script is used to compile and link both shared and static
351 libraries. They are placed in a subdirectory called .libs when they are newly
352 built. The programs pcretest and pcregrep are built to use these uninstalled
353 libraries (by means of wrapper scripts in the case of shared libraries). When
354 you use "make install" to install shared libraries, pcregrep and pcretest are
355 automatically re-built to use the newly installed shared libraries before being
356 installed themselves. However, the versions left in the source directory still
357 use the uninstalled libraries.
359 To build PCRE using static libraries only you must use --disable-shared when
360 configuring it. For example:
362 ./configure --prefix=/usr/gnu --disable-shared
364 Then run "make" in the usual way. Similarly, you can use --disable-static to
365 build only shared libraries.
368 Cross-compiling on a Unix-like system
369 -------------------------------------
371 You can specify CC and CFLAGS in the normal way to the "configure" command, in
372 order to cross-compile PCRE for some other host. However, during the building
373 process, the dftables.c source file is compiled *and run* on the local host, in
374 order to generate the default character tables (the chartables.c file). It
375 therefore needs to be compiled with the local compiler, not the cross compiler.
376 You can do this by specifying CC_FOR_BUILD (and if necessary CFLAGS_FOR_BUILD;
377 there are also CXX_FOR_BUILD and CXXFLAGS_FOR_BUILD for the C++ wrapper)
378 when calling the "configure" command. If they are not specified, they default
379 to the values of CC and CFLAGS.
382 Using HP's ANSI C++ compiler (aCC)
383 ----------------------------------
385 Unless C++ support is disabled by specifying the "--disable-cpp" option of the
386 "configure" script, you *must* include the "-AA" option in the CXXFLAGS
387 environment variable in order for the C++ components to compile correctly.
389 Also, note that the aCC compiler on PA-RISC platforms may have a defect whereby
390 needed libraries fail to get included when specifying the "-AA" compiler
391 option. If you experience unresolved symbols when linking the C++ programs,
392 use the workaround of specifying the following environment variable prior to
393 running the "configure" script:
395 CXXLDFLAGS="-lstd_v2 -lCsup_v2"
398 Testing PCRE
399 ------------
401 To test PCRE on a Unix system, run the RunTest script that is created by the
402 configuring process. There is also a script called RunGrepTest that tests the
403 options of the pcregrep command. If the C++ wrapper library is build, three
404 test programs called pcrecpp_unittest, pcre_scanner_unittest, and
405 pcre_stringpiece_unittest are also built.
407 Both the scripts and all the program tests are run if you obey "make check" or
408 "make test". For other systems, see the instructions in NON-UNIX-USE.
410 The RunTest script runs the pcretest test program (which is documented in its
411 own man page) on each of the testinput files (in the testdata directory) in
412 turn, and compares the output with the contents of the corresponding testoutput
413 files. A file called testtry is used to hold the main output from pcretest
414 (testsavedregex is also used as a working file). To run pcretest on just one of
415 the test files, give its number as an argument to RunTest, for example:
417 RunTest 2
419 The first test file can also be fed directly into the perltest.pl script to
420 check that Perl gives the same results. The only difference you should see is
421 in the first few lines, where the Perl version is given instead of the PCRE
422 version.
424 The second set of tests check pcre_fullinfo(), pcre_info(), pcre_study(),
425 pcre_copy_substring(), pcre_get_substring(), pcre_get_substring_list(), error
426 detection, and run-time flags that are specific to PCRE, as well as the POSIX
427 wrapper API. It also uses the debugging flag to check some of the internals of
428 pcre_compile().
430 If you build PCRE with a locale setting that is not the standard C locale, the
431 character tables may be different (see next paragraph). In some cases, this may
432 cause failures in the second set of tests. For example, in a locale where the
433 isprint() function yields TRUE for characters in the range 128-255, the use of
434 [:isascii:] inside a character class defines a different set of characters, and
435 this shows up in this test as a difference in the compiled code, which is being
436 listed for checking. Where the comparison test output contains [\x00-\x7f] the
437 test will contain [\x00-\xff], and similarly in some other cases. This is not a
438 bug in PCRE.
440 The third set of tests checks pcre_maketables(), the facility for building a
441 set of character tables for a specific locale and using them instead of the
442 default tables. The tests make use of the "fr_FR" (French) locale. Before
443 running the test, the script checks for the presence of this locale by running
444 the "locale" command. If that command fails, or if it doesn't include "fr_FR"
445 in the list of available locales, the third test cannot be run, and a comment
446 is output to say why. If running this test produces instances of the error
448 ** Failed to set locale "fr_FR"
450 in the comparison output, it means that locale is not available on your system,
451 despite being listed by "locale". This does not mean that PCRE is broken.
453 The fourth test checks the UTF-8 support. It is not run automatically unless
454 PCRE is built with UTF-8 support. To do this you must set --enable-utf8 when
455 running "configure". This file can be also fed directly to the perltest script,
456 provided you are running Perl 5.8 or higher. (For Perl 5.6, a small patch,
457 commented in the script, can be be used.)
459 The fifth test checks error handling with UTF-8 encoding, and internal UTF-8
460 features of PCRE that are not relevant to Perl.
462 The sixth and test checks the support for Unicode character properties. It it
463 not run automatically unless PCRE is built with Unicode property support. To to
464 this you must set --enable-unicode-properties when running "configure".
466 The seventh, eighth, and ninth tests check the pcre_dfa_exec() alternative
467 matching function, in non-UTF-8 mode, UTF-8 mode, and UTF-8 mode with Unicode
468 property support, respectively. The eighth and ninth tests are not run
469 automatically unless PCRE is build with the relevant support.
472 Character tables
473 ----------------
475 PCRE uses four tables for manipulating and identifying characters whose values
476 are less than 256. The final argument of the pcre_compile() function is a
477 pointer to a block of memory containing the concatenated tables. A call to
478 pcre_maketables() can be used to generate a set of tables in the current
479 locale. If the final argument for pcre_compile() is passed as NULL, a set of
480 default tables that is built into the binary is used.
482 The source file called chartables.c contains the default set of tables. This is
483 not supplied in the distribution, but is built by the program dftables
484 (compiled from dftables.c), which uses the ANSI C character handling functions
485 such as isalnum(), isalpha(), isupper(), islower(), etc. to build the table
486 sources. This means that the default C locale which is set for your system will
487 control the contents of these default tables. You can change the default tables
488 by editing chartables.c and then re-building PCRE. If you do this, you should
489 probably also edit Makefile to ensure that the file doesn't ever get
490 re-generated.
492 The first two 256-byte tables provide lower casing and case flipping functions,
493 respectively. The next table consists of three 32-byte bit maps which identify
494 digits, "word" characters, and white space, respectively. These are used when
495 building 32-byte bit maps that represent character classes for code points less
496 than 256.
498 The final 256-byte table has bits indicating various character types, as
499 follows:
501 1 white space character
502 2 letter
503 4 decimal digit
504 8 hexadecimal digit
505 16 alphanumeric or '_'
506 128 regular expression metacharacter or binary zero
508 You should not alter the set of characters that contain the 128 bit, as that
509 will cause PCRE to malfunction.
512 File manifest
513 -------------
515 The distribution should contain the following files:
517 (A) Source files of the PCRE library functions and their headers:
519 dftables.c auxiliary program for building chartables.c
521 pcreposix.c )
522 pcre_compile.c )
523 pcre_config.c )
524 pcre_dfa_exec.c )
525 pcre_exec.c )
526 pcre_fullinfo.c )
527 pcre_get.c ) sources for the functions in the library,
528 pcre_globals.c ) and some internal functions that they use
529 pcre_info.c )
530 pcre_maketables.c )
531 pcre_newline.c )
532 pcre_ord2utf8.c )
533 pcre_refcount.c )
534 pcre_study.c )
535 pcre_tables.c )
536 pcre_try_flipped.c )
537 pcre_ucp_searchfuncs.c )
538 pcre_valid_utf8.c )
539 pcre_version.c )
540 pcre_xclass.c )
541 pcre_printint.src ) debugging function that is #included in pcretest,
542 ) and can also be #included in pcre_compile()
543 pcre.h ) a version of the public PCRE header file
544 ) for use in non-"configure" environments
545 pcre.h.in template for pcre.h when built by "configure"
546 pcreposix.h header for the external POSIX wrapper API
547 pcre_internal.h header for internal use
548 ucp.h ) headers concerned with
549 ucpinternal.h ) Unicode property handling
550 ucptable.h ) (this one is the data table)
552 config.h ) a version of config.h for use in non-"configure"
553 ) environments
554 config.h.in template for config.h when built by "configure"
556 pcrecpp.h public header file for the C++ wrapper
557 pcrecpparg.h.in template for another C++ header file
558 pcre_scanner.h public header file for C++ scanner functions
559 pcrecpp.cc )
560 pcre_scanner.cc ) source for the C++ wrapper library
562 pcre_stringpiece.h.in template for pcre_stringpiece.h, the header for the
563 C++ stringpiece functions
564 pcre_stringpiece.cc source for the C++ stringpiece functions
566 (B) Source files for programs that use PCRE:
568 pcredemo.c simple demonstration of coding calls to PCRE
569 pcregrep.c source of a grep utility that uses PCRE
570 pcretest.c comprehensive test program
572 (C) Auxiliary files:
574 AUTHORS information about the author of PCRE
575 ChangeLog log of changes to the code
576 INSTALL generic installation instructions
577 LICENCE conditions for the use of PCRE
578 COPYING the same, using GNU's standard name
579 Makefile.in ) template for Unix Makefile, which is built by
580 ) "configure"
581 Makefile.am ) the automake input that was used to create
582 ) Makefile.in
583 NEWS important changes in this release
584 NON-UNIX-USE notes on building PCRE on non-Unix systems
585 README this file
586 RunTest.in template for a Unix shell script for running tests
587 RunGrepTest.in template for a Unix shell script for pcregrep tests
588 aclocal.m4 m4 macros (generated by "aclocal")
589 config.guess ) files used by libtool,
590 config.sub ) used only when building a shared library
591 configure a configuring shell script (built by autoconf)
592 configure.ac ) the autoconf input that was used to build
593 ) "configure" and config.h
594 depcomp ) script to find program dependencies, generated by
595 ) automake
596 doc/*.3 man page sources for the PCRE functions
597 doc/*.1 man page sources for pcregrep and pcretest
598 doc/html/* HTML documentation
599 doc/pcre.txt plain text version of the man pages
600 doc/pcretest.txt plain text documentation of test program
601 doc/perltest.txt plain text documentation of Perl test program
602 install-sh a shell script for installing files
603 libpcre.pc.in template for libpcre.pc for pkg-config
604 libpcrecpp.pc.in template for libpcrecpp.pc for pkg-config
605 ltmain.sh file used to build a libtool script
606 missing ) common stub for a few missing GNU programs while
607 ) installing, generated by automake
608 mkinstalldirs script for making install directories
609 perltest.pl Perl test program
610 pcre-config.in source of script which retains PCRE information
611 pcrecpp_unittest.c )
612 pcre_scanner_unittest.c ) test programs for the C++ wrapper
613 pcre_stringpiece_unittest.c )
614 testdata/testinput* test data for main library tests
615 testdata/testoutput* expected test results
616 testdata/grep* input and output for pcregrep tests
618 (D) Auxiliary files for cmake support
620 CMakeLists.txt
621 config-cmake.h.in
623 (E) Auxiliary files for VPASCAL
625 makevp.bat
626 !compile.txt
627 !linklib.txt
628 pcregexp.pas
630 (F) Miscellaneous
632 RunTest.bat a script for running tests under Windows
634 Philip Hazel
635 Email local part: ph10
636 Email domain: cam.ac.uk
637 Last updated: March 2007


Name Value
svn:eol-style native
svn:keywords "Author Date Id Revision Url"

  ViewVC Help
Powered by ViewVC 1.1.5