This 'project' aims at implementing basic parsers for a very simple grammar which describes arithmetic expressions.

Below is the grammar in BNF:

<integer>       ::= [0-9][0-9]*

<primary-exp>   ::= <integer> | "(" <exp> ")"

<mult-exp>      ::= <primary-exp>
          | <mult-exp> "*" <primary-exp>

<sum-exp>       ::= <mult-exp>
          | <sum-exp> "+" <mult-exp>
          | <sum-exp> "-" <mult-exp>

<exp>       ::= <sum-exp>

Same grammar using EBNF:

digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;

integer = [ "-" ] , digit , {digit} ;

val = '(' sum ')' | integer ;

prod = val , { ('*'|'/'|'%'), val } ;

sum = prod , { ('+'|'-'), prod } ;

expr = sum

rdp.c: Implements the parser using a recursive descent parser (a common way to program an LL parser). With many levels of precedence, implementing this grammar with a predictive recursive-descent parser can become inefficient. Parsing a number, for example, can require four function calls (one for each non-terminal in the grammar, until we reach primary-exp).

http://www.garshol.priv.no/download/text/bnf.html#id1.2.

opp.c: The operator-precedence parser can parse all LR(1) grammars where two consecutive nonterminals never appear in the right-hand side of any rule.

They can be written to consult an operator table at runtime, which makes them suitable for languages that can add to or change their operators while parsing.

The idea is that we can left associate the arithmetic operations as long as we find operators with the same precedence, but we have to save a temporary result to evaluate higher precedence operators.