已下载好的ctags安装包

# PackCC # ## Overview ## **PackCC** is a parser generator for C. Its main features are as follows: - Generates your parser in C from a grammar described in a **PEG**, - Gives your parser great efficiency by **packrat parsing**, - Supports direct and indirect **left-recursive** grammar rules. The grammar of your parser can be described in a **PEG** ([Parsing Expression Grammar](http://en.wikipedia.org/wiki/Parsing_expression_grammar)). The PEG is a [top-down parsing language](http://en.wikipedia.org/wiki/Top-down_parsing_language), and is similar to the [regular-expression](http://en.wikipedia.org/wiki/Regular_expression) grammar. Compared with a bottom-up parsing language, like Yacc's one, the PEG is much more intuitive and cannot be ambiguous. The PEG does not require tokenization to be a separate step, and tokenization rules can be written in the same way as any other grammar rules. Your generated parser can parse inputs very efficiently by **packrat parsing**. The packrat parsing is the [recursive descent parsing](http://en.wikipedia.org/wiki/Recursive_descent_parser) algorithm that is accelerated using [memoization](http://en.wikipedia.org/wiki/Memoization). By using packrat parsing, any input can be parsed in linear time. Without it, however, the resulting parser could exhibit exponential time performance in the worst case due to the unlimited look-ahead capability. Unlike common packrat parsers, PackCC can support direct and indirect **left-recursive** grammar rules. This powerful feature enables you to describe your language grammar in a much simpler way. <small>(The algorithm is based on the paper [*"Packrat Parsers Can Support Left Recursion"*](http://www.cs.ucla.edu/~todd/research/pub.php?id=pepm08) authored by A. Warth, J. R. Douglass, and T. Millstein.)</small> Some additional features are as follows: - Thread-safe and reentrant, - Supports UTF-8 multibyte characters (version 1.4.0 or later), - Generates more ease-of-understanding parser source codes, - Consists of just a single compact source file, - Under MIT license. (not under a certain contagious license!) The generated code is beautified and as ease-of-understanding as possible. Actually, it uses lots of *goto* statements, but the control flows are much more traceable than *goto* spaghetti storms generated by Yacc or other parser generators. This feature is irrelevant to common users, but helpful for PackCC developers to debug it. PackCC itself is under MIT license, but you can distribute your generated code under any license you like. ## Installation ## You can obtain the executable `packcc` by compiling [`src/packcc.c`](src/packcc.c) using your favorite C compiler. For convenience, the build environments using GCC, Clang, and Microsoft Visual Studio are prepared under [`build`](build) directory. ### Using GCC ### #### Other than MinGW #### `packcc` will be built in both directories `build/gcc/debug/bin` and `build/gcc/release/bin` using `gcc` by executing the following commands: ``` cd build/gcc make make check # bats-core and uncrustify are required (see tests/README.md) ``` `packcc` in the directory `build/gcc/release/bin` is suitable for practical use. #### MinGW #### `packcc` will be built in both directories `build/mingw-gcc/debug/bin` and `build/mingw-gcc/release/bin` using `gcc` by executing the following commands: ``` cd build/mingw-gcc make make check # bats-core and uncrustify are required (see tests/README.md) ``` `packcc` in the directory `build/mingw-gcc/release/bin` is suitable for practical use. ### Using Clang ### #### Other than MinGW #### `packcc` will be built in both directories `build/clang/debug/bin` and `build/clang/release/bin` using `clang` by executing the following commands: ``` cd build/clang make make check # bats-core and uncrustify are required (see tests/README.md) ``` `packcc` in the directory `build/clang/release/bin` is suitable for practical use. #### MinGW #### `packcc` will be built in both directories `build/mingw-clang/debug/bin` and `build/mingw-clang/release/bin` using `clang` by executing the following commands: ``` cd build/mingw-clang make make check # bats-core and uncrustify are required (see tests/README.md) ``` `packcc` in the directory `build/mingw-clang/release/bin` is suitable for practical use. ### Using Microsoft Visual Studio ### You have to install Microsoft Visual Studio 2019 in advance. After that, you can build `packcc.exe` by the following instructions: - Open the solution file `build\msvc\msvc.sln`, - Select a preferred solution configuration (*Debug* or *Release*) and a preferred solution platform (*x64* or *x86*), - Invoke the *Build Solution* menu item. `packcc.exe` will appear in `build\msvc\XXX\YYY` directory. Here, `XXX` is `x64` or `x86`, and `YYY` is `Debug` or `Release`. `packcc.exe` in the directory `build\msvc\XXX\Release` is suitable for practical use. ## Usage ## ### Command ### You must prepare a PEG source file (see the following section). Let the file name `example.peg` for example. ``` packcc example.peg ``` By running this, the parser source `example.h` and `example.c` are generated. If no PEG file name is specified, the PEG source is read from the standard input, and `-.h` and `-.c` are generated. The base name of the parser source files can be changed by `-o` option. ``` packcc -o parser example.peg ``` By running this, the parser source `parser.h` and `parser.c` are generated. If you want to disable UTF-8 support, specify the command line option `-a` or `--ascii` (version 1.4.0 or later). If you want to insert `#line` directives in the generated source and header files, specify the command line option `-l` or `--lines` (version 1.7.0 or later). It is helpful to trace compilation errors of the generated source and header files back to the codes written in the PEG source file. If you want to confirm the version of the `packcc` command, execute the below. ``` packcc -v ``` ### Syntax ### A grammar consists of a set of named rules. A rule definition can be split into multiple lines. **_rulename_ `<-` _pattern_** The _rulename_ is the name of the rule to define. The _pattern_ is a text pattern that contains one or more of the following elements. **_rulename_** The element stands for the entire pattern in the rule with the name given by _rulename_. **_variable_`:`_rulename_** The element stands for the entire pattern in the rule with the name given by _rulename_. The _variable_ is an identifier associated with the semantic value returned from the rule by assigning to `$$` in its action. The identifier can be referred to in subsequent actions as a variable. The example is shown below. ``` term <- l:term _ '+' _ r:factor { $$ = l + r; } ``` A variable identifier must consist of alphabets (both uppercase and lowercase letters), digits, and underscores. The first letter must be an alphabet. The reserved keywords in C cannot be used. **_sequence1_ `/` _sequence2_ `/` ... `/` _sequenceN_** Each _sequence_ is tried in turn until one of them matches, at which time matching for the overall pattern succeeds. If no _sequence_ matches then the matching for the overall pattern fails. The operator slash (`/`) has the least priority. The example is shown below. ``` 'foo' rule1 / 'bar'+ [0-9]? / rule2 ``` This pattern tries matching of the first sequence (`'foo' rule1`). If it succeeds, then the overall pattern matching succeeds and ends without evaluating the subsequent sequences. Otherwise, it tries matching of the next sequence (`'bar'+ [0-9]?`). If it succeeds, then the overall pattern matching succeeds and ends without evaluating the subsequent sequence. Finally, it tries matching of the last sequence (`rule2`). If it succeeds, then the overall pattern matching succeeds. Otherwise, the overall pattern matching fails. **`'`_string_`'`** A character or string enclosed in single quotes is matched literally. The ANSI C escape sequences are recognized wit