1. You write a PEG grammar describing the parsing task
2. You can then:
   • Use Aurochs directly to parse an input text using that grammar and display the parse tree in XML.
   • Use Aurochs to compile the PEG grammar into an automaton.
   • Run the compiled automaton from Ocaml, Java, C using the existing bindings. This gives you a parse tree.
   • Write your own C binding for your favorite language.
   • Generate a native C or Ocaml parser.

    hex_integer ::= "0x" [0-9a-fA-F]+;
    decimal_integer ::= [0-9]+;
    integer ::= hex_integer | decimal_integer;
    space ::= ' ';
    start ::= space* integer (space+ integer)* space* EOF;
            

• Character litterals: 'c' for the single ASCII character 'c'
• String litterals: "hello" for the string
• Beginning-of-file BOF and end-of-file EOF
• Any character sigma
• The empty string epsilon
• Character ranges [a-zA-Z0-9] or their complements [^\n\t ]
• Concatenation: a b parses a then b. Note that there exist operators, such as infixing, which change the meaning of concatenation.
• Ordered disjunction a | b. Here, Aurochs attempts to parse a at the current position. If it manages, it will never try to parse b at the current position.. If it fails, it will never try to parse a again at that position, and will try to parse b. If b fails, the whole production fails.
• Negation: ~a attempts to parse a and succeeds, without consuming any input, if a fails. If a succeeds, it fails (and thus doesn't consume its inputs anyway.)
• Conjunction: &a. Parses a, but without consuming it. Thus "big" &"ger" "gerbil" will parse "big", then check that "ger" is parseable but without consuming the input (or advancing the cursor, if you prefer), then parse "gerbil". Thus it will accept "biggerbil", but not "biggergerbil".
• Expressions can be grouped using parentheses.
• Repetition: a* parses as many occurences of a as possible, including zero. a+ parses at least one occurences of a.
• Option: a? parses zero or one occurences of a.

    hex_integer ::= "0x" value:[0-9a-fA-F]+;
    decimal_integer ::= value:[0-9]+;
    integer ::= <Hex>hex_integer</Hex> | <Dec>decimal_integer </Dec>;
    space ::= ' ';
    start ::= space* <IntegerList>integer (space+ integer)*</IntegerList> space* EOF;
            

• Each node of the parse tree has the foll
• Construct a single node : <name> x </name> will build a single node with the given name, if the expression x is parsable. The nodes constructed by the expression x will be appended as children to name, as will be any attributes and tokens not caught by other children.
  It is possible to abbreviate <name> </name> as <name/>.
• Add an attribute: attr:x adds an attribute named attr to the current node. The value of the attribute will be the segment of the input spanned by the whole expression x, regardless of construction or attribute directives in x itself.
• Add a token: { x } adds the segment of the input spanned by the expression x as a token to the current node.
• Positions: the constructor position can be used in attributes to encode the current position, in bytes. Thus one can write <name> start:position x y z end:position </name> to get the beginning and end of the expression x y z.

• appending x do ... done transforms them into a ::= a x
• prepending x do ... done transforms them into a ::= x a
• surrounding x do ... done transforms them into a ::= x a x

• outfixing x do ... done transforms them into x a x b x c x
• suffixing x do ... done transforms them into a x b x c x
• prefixing x do ... done transforms them into x a x b x c

• If you cannot split your language into a lexer and a parser, packrat parsing is for you.
• Your are in the process of designing your language and you want a quick parse-fix cycle.
• Because you want a parsing technology that is easy to understand and that you could re-implement in your own.
• If you have multiple grammars with incompatible lexical structures, you cannot combine them using traditional parser generators, because they have a lexing phase. A hand-crafter parser or packrat parsing is your only solution.
• If you want to use a given grammar definition with more than one programming language.
• If your language is not CFG, maybe packrat parsing can do the job.
• Because you might find that resolving ambiguities by operator precedence rules is hard to understand and not very modular.
• If your patterns are such that regular expressions don't cut the job or get awfully complex while grammars seem overkill, and your input strings are small (less than 10k), then Aurochs is a very attractive alternative.

• Install Objective Caml 3.10 or later:
  If you are using Debian or a recent Ubuntu, run apt-get install ocaml-core
  Otherwise, go to caml.inria.fr and follow the instructions there.
• Get the Aurochs source code:
  Download the latest source tarball: aurochs-v1.0.93.tar.gz and unpack it.
  Or, if you have Mercurial, type hg clone http://aurochs.fr/hg/aurochs aurochs to get a local copy of the latest version.
  Type make
  Type PREFIX=/usr/local sudo make install to install the aurochs binary in /usr/local/bin; the Ocaml libraries will be installed in Ocaml's library path.
  If you want to use Aurochs from Java, look into the java directory, which contains the required bindings and a simple calculator example.