Clear the buffer after reading.

Rulevalidation is now done by the Rule.

The allocated memory wasn't freed in case of an error. Also the wrong
constant has been used, which happens to be the same.

Note, that raw_get_rule won't be implemented yet, because an allocated
Rule, which contains observer pointers has to be returned, which is
difficult to annotate.

As most of the code, is now already abstracted by the Rule, the separate
static method isn't worth it any more.

The caller now has to first construct a Rule object, which can then be
passed to a Grammar.

If raw_add or raw_set is used, the given Rule is cleared, so that it can
be reused by the caller and a call to GR_Rule_free doesn't result in
double free and data corruption, but sole free(rule) is still
sufficient.

This allows to reuse a rule, after it has been added to a grammar.

Make the functions actually static.

This function checks, whether a given rule forms a valid rule using the
symbols defined by a grammar.

Obviously, this should be const.

This method moves the internal data from one rule to another. The dest
is deemed uninitialized before, src has to be assumed uninitialized
after. Violating the latter will result in a double free or data
corruption. If src should be afterwards Rule_init has to be called. If
dest was used beforehand, Rule_free has to be called.

The logging implementation was copied from another project. It just
prints to stderr and isn't configurable. A macro from the "GNU Autoconf
Archive" is used to add printf-like-function annotations.

This will be useful for using some Autoconf macros.

This is useful to incorporate a rule without overhead.

This is just the same implementation as for the source symbols.

It is easy to mess up with realloc. That's why this should definitely be
tested.

This allows the sentinel to be used as return value.

This reduces unnecessary checks, when the index is hardcoded.

This will provide methods to manipulate a rule. It is separated from a
grammar in order to simplify it. Essentially it is just a wrapper for
two arrays.