Describing a grammar and associated parser In the process of writing a Turing machine simulator, I decided on a machine representation in ASCII that closely mirrors Turing's original machine tables. I am interested in the formal categorization of the grammar and the simplest type of parser required to implement it, and in a more formal description of same. The grammar is as follows:

&lt;instruction&gt; ::= &lt;ident&gt; "," &lt;symbol&gt; "," &lt;operation&gt; "," &lt;ident&gt; &lt;EOL&gt;
      &lt;ident&gt; ::= &lt;char&gt;
      &lt;symbol ::= &lt;char&gt; | 'None'
  &lt;operation&gt; ::= &lt;movement&gt; | &lt;write&gt; &lt;movement&gt;
      &lt;write&gt; ::= 'P' &lt;char&gt; | 'E'
    &lt;movement ::= 'R' | 'L'


An example Turing machine table written in this grammar is as follows:

b, None, P0R, c
c, None, R,   e
e, None, P1R, f
f, None, R,   b


It is clear to me that since this grammar is expressible in BNF, it must then be at most context-free, but is there a more accurate (more strict) categorization? The lack of left-recursion implies that it could be parsed with a recursive descent parser, but is there a simpler parser that would be capable of this grammar? How would one describe this grammar and its (simplest) associated parser?
if you don't count rembering the symbols of previous lines it's a regular language here's the regex as I see it (&lt;char&gt; is translated to [a-z])

[a-z]\s*,\s*([a-z]|None)\s*,\s*(R|L|P[a-z](R|L))\s*,\s*[a-z]\n


use capturing groups as necessary ;)