<system goal>            -> <declaration list>

<declaration list>       -> <declaration> <declaration tail>

<declaration tail>       -> <declaration> <declaration tail>
<declaration tail>       -> L

<declaration>            -> <class specifier> ";"
<declaration>            -> <inline function>

<class specifier>        -> <class head> <class tail>

<class head>             -> <class key> <identifier> <base info>

<class key>              -> class
<class key>              -> struct

<base info>              -> : <base list>
<base info>              -> L

<base list>              -> <base item> <base tail>
<base tail>              -> , <base list>

<base item>              -> public <identifier>

<class tail>             -> "{" <member specification> "}"
<class tail>             -> L

<inline function>        -> inline <ignored> "{" <ignored> "}"

<member specification>   -> <member declaration> <member specification>
<member specification>   -> <access specifier> <member specification>
<member specification>   -> <signal or slot> ":" <member specification>
<member specification>   -> L

<member declaration>     -> <construtor declaration>
<member declaration>     -> <destructor declaration>
<member declaration>     -> <method declaration>
<member declaration>     -> <variable declaration>
<member declaration>     -> <enum declaration>
<member declaration>     -> L

<access specifier>       -> public <signal or slot> ":"
<access specifier>       -> private <signal or slot> ":"
<access specifier>       -> protected <signal or slot> ":"

<signal or slot>         -> signals
<signal or slot>         -> slots
<signal or slot>         -> L

<constructor declaration>-> <identifier> "(" <parameter list> ")" ";"
<destructor declaration> -> "~" <identifier> "(" ")" ";"

<method declaration>     -> <storage class specifier> <type specifier>
                            <identifier> "(" <parameter list> ")" 
							<const affix> <method tail>

<method tail>            -> ";"
<method tail>           -> "{" <ignored> "}"
(* The pseudo nonterminal <ignored> means that tokens are consumed until
the terminating "} is encountered

<const affix>            -> const
<const affix>            -> L
						 
<sc specifier>           -> static
<sc specifier>           -> inline
<sc specifier>           -> virtual
<sc specifier>           -> L

<type specifier>         -> <const affix> [unsigned] <identifier> [ * | ** | & ] [ <identifier> ]
(* Not in simplified BNF *)

<parameter list>         -> <parameter declaration> <parameter tail>
<parameter list>         -> L
<parameter tail>         -> , <parameter list>
<parameter tail>         -> L

(* The parsing methods deviate from the parameter productions below *)	
<parameter declaration>  -> <const affix> <identifier> <parameter id>
<parameter id>           -> <identifier> <initializer>
<parameter id>           -> L

<initializer>            -> = <constant>
<initializer>            -> L

<variable declaration>   -> <sc specifier> <type specifier>
                            <identifier> <initializer>

<enum declaration>       -> enum <enum tag> "{" <enum list> "}"

<enum tag>               -> <identifier>
<enum tag>               -> L

<enum list>              -> <enum member> <enum tail>
<enum tail>              -> , <enum list>
<enum tail>              -> L

------ Let's start using more efficient notation for recursive
descent parsers, starting with enums.

<enum list>              -> <enum member> { "," <enum member> } ";"
<enum member>            -> <identifier> [ "=" <enum value> ]
<enum value>             -> <constant> | <identifier> 

----------------------------------------------------------------


<enum member>            -> <identifier> <enum member tail>
<enum member tail>       -> = <enum value>
<enum member tail>       -> L

<enum value>             -> <const>
<enum value>             -> <identifier>

<const>                  -> decimal, hex, or octal constant, optionally
							preceeded by a -
						  
** NOTES **
There is only one type of declaration now -- a class
We are only recognizing public base classes
Type specifier could be a pointer or ref type

TODO: QENUM, QPROPERTY
