>NAME
libparser - Context-free grammar parsing library
DESCRIPTION
libparser is a small C library that parses input based on a
precompiled context-free grammar.
To use libparser, a developer should write a syntax for the
input that his application shall parse, in a syntax based
on Extended Backus–Naur form (EBNF) (somewhat simplified but
also somewhat extended). libparser-generate(1) is then used
to create a C source file describing the syntax, which shall
be compiled into an object file with a C compiler. This file
provides a definition of a global variable declared in
<libparser.h>: libparser_rule_table. This variable is used
when calling libparser_parse_file(3) to parse the application's
input.
libparser is proudly non-self-hosted.
EXTENDED DESCRIPTION
Syntax
The grammar for libparser-generate(1)'s input can be described
in its own grammar:
(* CHARACTER CLASSES *)
_space = " " | "\n" | "\t";
_alpha = <"a", "z"> | <"A", "Z">;
_octal = <"0", "7">;
_digit = <"0", "9">;
_xdigit = _digit | <"a", "f"> | <"A", "F">;
_nonascii = <128, 255>;
(* WHITESPACE/COMMENTS, THE GRAMMAR IS FREE-FORM *)
_comment_char = _space | !"*", !"\"", <"!", 0xFF>;
_comment_tail = [_comment_char], [_string], ("*)" | _comment_tail | -);
_comment = "(*", _comment_tail;
_ = {_space | _comment};
(* IDENTIFIERS *)
_identifier_head = _alpha | _digit | _nonascii | "_";
_identifier_tail = _identifier_head | "-";
identifier = _identifier_head, {_identifier_tail};
(* STRINGS *)
_escape_simple = "\\" | "\"" | "'" | "a" | "b" | "f" | "n" | "r" | "v";
_escape_hex = ("x" | "X"), _xdigit, _xdigit;
_escape_octal = _octal, {_octal}; (* May not exceed 255 in base 10 *)
_escape = _escape_simple | _escape_hex | _escape_octal | -;
_character = "\\", _escape | !"\"", <" ", 0xFF>;
_string = "\"", _character, {_character}, ("\"" | -);
string = _string
character = "\"", _character, ("\"" | -);
(* INTEGERS *)
_decimal = _digit, {_digit};
_hexadecimal = "0", ("x" | "X"), _xdigit, {_xdigit};
integer = _decimal | _hexadecimal; (* May not exceed 255. *)
(* GROUPINGS *)
_low = character | integer;
_high = character | integer;
rejection = "!", _, _operand;
concatenation = _operand, {_, ",", _, _operand};
alternation = concatenation, {_, "|", _, concatenation};
optional = "[", _, _expression, _, "]";
repeated = "{", _, _expression, _, "}";
group = "(", _, _expression, _, ")";
char-range = "<", _, _low, _, ",", _, _high, "_", ">";
exception = "-";
embedded-rule = identifier;
_literal = char-range | exception | string;
_group = optional | repeated | group | embedded-rule;
_operand = _group | _literal | rejection;
_expression = alternation;
(* RULES *)
rule = identifier, _, "=", _, _expression, _, ";";
(* This is the root rule of the grammar. *)
grammar = _, {rules, _};
The file must be encoded in UTF-8, with LF as the line
break (CR and FF are illegal just becuase).
In alternations, the first (leftmost) match is selected. The
parser is able to backtrack incase it later turns out that it
could not finish that branch. Whenever an exception is
reached, the parser will terminate there.
Repeated symbols may occour any number of times, including
zero. The compiler is able to backtrack if it takes too much.
Concatenation has higher precedence than alternation,
groups ("(", ..., ")") have no semantic meaning and are useful
only to put a alternation inside a concatenation without
creating a new rule for that.
In character ranges, the _high and _low values must be at
least 0 and at most 255, and _high must be greater than _low.
Rules that begin with an underscore will not show up for
the application in the parse result, the rest of the rules
will appear in the tree-formatted result.
Left recursion is illegal (it will cause stack overflow at
runtime as the empty condition before the recursion is always
met).